> ## Documentation Index
> Fetch the complete documentation index at: https://ai-kb.automationanywhere.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Saídas

> Defina esquemas JSON para estruturar respostas de agentes em um formato consistente

Saídas Estruturadas permitem que você defina esquemas JSON que seus agentes de IA devem seguir ao responder. Isso garante respostas consistentes e legíveis por máquina que podem ser facilmente integradas com outros sistemas, APIs ou fluxos de trabalho automatizados.

## Visão Geral

Saídas Estruturadas permitem que você:

* **Defina o Formato da Resposta** - Crie esquemas JSON personalizados para respostas de agentes
* **Garanta Consistência** - Garanta que agentes sempre retornem dados na mesma estrutura
* **Habilite Integração** - Torne as respostas facilmente consumíveis por outros sistemas
* **Melhore a Análise** - Elimine a necessidade de análise de texto complexa

## Como Funciona

### 1. Crie um Esquema JSON

Defina a estrutura que você deseja que seu agente siga:

* **Campos** - Especifique campos obrigatórios e opcionais
* **Tipos de Dados** - Defina tipos (string, number, boolean, array, object)
* **Estruturas Aninhadas** - Crie objetos JSON aninhados complexos
* **Exemplos** - Forneça valores de exemplo para clareza

### 2. Atribua ao Agente

Selecione o esquema de saída estruturada para o seu agente:

* **Aba Geral** - Escolha entre as saídas estruturadas disponíveis
* **Específico do Agente** - Cada agente pode usar um esquema diferente
* **Seleção Dinâmica** - Altere esquemas conforme necessário

### 3. Resposta do Agente

Quando habilitado, o agente irá:

* **Formatar como JSON** - Retornar respostas na estrutura JSON especificada
* **Seguir o Esquema** - Incluir todos os campos obrigatórios
* **Manter a Estrutura** - Preservar objetos e arrays aninhados
* **Validar o Formato** - Garantir que as respostas correspondam ao esquema

## Criando Saídas Estruturadas

### Passo 1: Acesse a Aba de Saída

1. Navegue até **Agentes** na barra lateral
2. Selecione um agente ou crie um novo
3. Clique em **Editar** para abrir o construtor de agentes
4. Vá para a aba **Saída**

### Passo 2: Crie um Novo Esquema

1. Clique no botão **Criar Novo**
2. Insira um título descritivo para sua saída estruturada
3. Use o construtor JSON para definir seu esquema

### Passo 3: Defina a Estrutura do Esquema

Use o construtor JSON visual para criar seu esquema:

#### Estrutura Básica

```json theme={null}
{
  "status": "string",
  "message": "string",
  "data": {
    "result": "string"
  }
}
```

#### Com Arrays

```json theme={null}
{
  "items": [
    {
      "id": "string",
      "name": "string",
      "value": "number"
    }
  ],
  "total": "number"
}
```

#### Estrutura Aninhada Complexa

```json theme={null}
{
  "response": {
    "summary": "string",
    "details": {
      "category": "string",
      "subcategory": "string",
      "metadata": {
        "created_at": "string",
        "updated_at": "string"
      }
    },
    "items": [
      {
        "id": "string",
        "properties": {
          "name": "string",
          "value": "number"
        }
      }
    ]
  }
}
```

### Passo 4: Salve o Esquema

1. Clique em **Salvar** para armazenar sua saída estruturada
2. O esquema agora está disponível para uso em agentes

## Atribuindo a Agentes

### Método 1: Pela Aba Geral

1. Abra o agente que deseja configurar
2. Vá para a aba **Geral**
3. Encontre a seção **Formato da Resposta**
4. Selecione sua saída estruturada no menu suspenso
5. Salve o agente

### Método 2: Pela Aba de Saída

1. Abra o agente que deseja configurar
2. Vá para a aba **Saída**
3. Selecione uma saída estruturada na lista
4. O agente usará este esquema para todas as respostas

## Casos de Uso

### Integração de API

**Cenário:** Você precisa de respostas do agente em um formato que pode ser consumido pela sua API.

**Exemplo de Esquema:**

```json theme={null}
{
  "status": "success",
  "code": 200,
  "data": {
    "result": "string",
    "timestamp": "string"
  }
}
```

**Resposta do Agente:**

```json theme={null}
{
  "status": "success",
  "code": 200,
  "data": {
    "result": "Task completed successfully",
    "timestamp": "2024-01-15T10:30:00Z"
  }
}
```

### Extração de Dados

**Cenário:** Extrair dados estruturados de texto não estruturado.

**Exemplo de Esquema:**

```json theme={null}
{
  "entities": [
    {
      "type": "string",
      "value": "string",
      "confidence": "number"
    }
  ],
  "summary": "string"
}
```

**Resposta do Agente:**

```json theme={null}
{
  "entities": [
    {
      "type": "person",
      "value": "John Doe",
      "confidence": 0.95
    },
    {
      "type": "company",
      "value": "TechCorp",
      "confidence": 0.88
    }
  ],
  "summary": "Extracted 2 entities from the text"
}
```

### Relatórios Formatados

**Cenário:** Gerar estruturas de relatórios consistentes.

**Exemplo de Esquema:**

```json theme={null}
{
  "report": {
    "title": "string",
    "date": "string",
    "sections": [
      {
        "heading": "string",
        "content": "string",
        "metrics": {
          "value": "number",
          "unit": "string"
        }
      }
    ],
    "summary": "string"
  }
}
```

### Automação de Fluxos de Trabalho

**Cenário:** Estruturar respostas para processamento automatizado de fluxos de trabalho.

**Exemplo de Esquema:**

```json theme={null}
{
  "action": "string",
  "parameters": {
    "key": "value"
  },
  "next_step": "string",
  "metadata": {
    "workflow_id": "string",
    "step_number": "number"
  }
}
```

## Melhores Práticas

### Design de Esquemas

1. **Seja Específico** - Defina claramente todos os campos e seus tipos
2. **Use Exemplos** - Inclua valores de exemplo no seu esquema
3. **Mantenha Simples** - Evite estruturas aninhadas excessivamente complexas quando possível
4. **Documente os Campos** - Use nomes de campos descritivos
5. **Considere Campos Opcionais** - Marque campos como opcionais quando apropriado

### Nomenclatura de Campos

* **Use Nomes Claros** - `user_name` em vez de `un`
* **Seja Consistente** - Siga uma convenção de nomenclatura (snake\_case, camelCase)
* **Evite Abreviações** - Use palavras completas quando possível
* **Agrupe Campos Relacionados** - Use objetos aninhados para dados relacionados

### Estrutura do Esquema

* **Plano Quando Possível** - Prefira estruturas planas para dados simples
* **Aninhe para Organização** - Use aninhamento para dados complexos e relacionados
* **Arrays para Listas** - Use arrays para coleções de itens semelhantes
* **Objetos para Grupos** - Use objetos para agrupar campos relacionados

### Testes

1. **Teste com Consultas Reais** - Verifique se o esquema funciona com perguntas reais do usuário
2. **Verifique Todos os Campos** - Garanta que todos os campos obrigatórios estejam preenchidos
3. **Valide os Tipos** - Confirme que os tipos de dados correspondem ao esquema
4. **Trate Casos Extremos** - Teste com dados incomuns ou faltantes

## Gerenciando Saídas Estruturadas

### Visualizando Todos os Esquemas

Na aba **Saída**, você pode:

* **Listar Todos os Esquemas** - Veja todas as saídas estruturadas no seu projeto
* **Pesquisar** - Encontre esquemas por nome
* **Ordenar** - Ordene por data de criação ou título
* **Ver Detalhes** - Veja a estrutura e metadados do esquema

### Editando Esquemas

1. Clique em um esquema na lista
2. Modifique a estrutura JSON usando o construtor visual
3. Clique em **Salvar** para atualizar o esquema
4. As alterações se aplicam a todos os agentes que usam este esquema

### Excluindo Esquemas

1. Encontre o esquema na lista
2. Clique no ícone **Excluir**
3. Confirme a exclusão
4. Os agentes usando este esquema voltarão às respostas de texto normais

<Warning>
  Excluir uma saída estruturada afetará todos os agentes atualmente usando-a. Certifique-se de atualizar esses agentes antes de excluir.
</Warning>

## Formato da Resposta

### Resposta Normal (Padrão)

Quando nenhuma saída estruturada é selecionada, os agentes retornam texto livre:

```
The user requested information about project status.
The project is currently in progress with 75% completion.
All milestones are on track.
```

### Resposta Estruturada

Quando uma saída estruturada é selecionada, os agentes retornam JSON:

```json theme={null}
{
  "status": "in_progress",
  "completion_percentage": 75,
  "milestones": [
    {
      "name": "Phase 1",
      "status": "completed"
    },
    {
      "name": "Phase 2",
      "status": "in_progress"
    }
  ],
  "on_track": true
}
```

## Integração com Prompt de Sistema

Quando uma saída estruturada é atribuída a um agente:

1. **Esquema Incluído** - O esquema JSON é adicionado ao prompt de sistema
2. **Instruções de Formato** - O agente recebe instruções de formatação explícitas
3. **Exemplo Fornecido** - O esquema serve como um formato de exemplo
4. **Validação** - O agente tenta corresponder à estrutura exata

## Recursos Avançados

### Valores Dinâmicos de Campos

Os esquemas podem incluir campos que se adaptam à resposta:

```json theme={null}
{
  "response_type": "string",
  "content": {
    "text": "string",
    "metadata": {}
  }
}
```

### Estruturas Condicionais

Use diferentes esquemas para diferentes tipos de resposta:

```json theme={null}
{
  "type": "success|error|warning",
  "message": "string",
  "data": {} // A estrutura varia por tipo
}
```

### Respostas com Array

Trate múltiplos itens nas respostas:

```json theme={null}
{
  "count": "number",
  "items": [
    {
      "id": "string",
      "data": {}
    }
  ]
}
```

## Solução de Problemas

### Agente Não Seguindo o Esquema

**Causas Possíveis:**

* Esquema não atribuído ao agente
* Estrutura do esquema complexa demais
* Agente precisa de instruções mais claras

**Soluções:**

* Verifique se a saída estruturada está selecionada na aba Geral
* Simplifique a estrutura do esquema
* Adicione descrições de campos mais explícitas
* Teste com consultas mais simples primeiro

### Respostas JSON Inválidas

**Causas Possíveis:**

* Esquema com erros de sintaxe
* Agente tendo dificuldade com estrutura complexa
* Campos obrigatórios faltando

**Soluções:**

* Valide a sintaxe do esquema no construtor JSON
* Verifique erros de validação JSON
* Simplifique o esquema se estiver complexo demais
* Revise as respostas do agente em busca de erros de análise

### Campos Faltantes

**Causas Possíveis:**

* Campos não claramente definidos
* Agente não compreende os requisitos dos campos
* Esquema vago demais

**Soluções:**

* Adicione descrições claras dos campos
* Forneça valores de exemplo no esquema
* Torne os campos opcionais se nem sempre disponíveis
* Teste com consultas específicas

## Exemplos

### Exemplo 1: Resposta de Suporte ao Cliente

**Esquema:**

```json theme={null}
{
  "ticket_id": "string",
  "status": "open|resolved|pending",
  "response": "string",
  "next_actions": ["string"],
  "priority": "low|medium|high|urgent"
}
```

**Resposta do Agente:**

```json theme={null}
{
  "ticket_id": "TKT-12345",
  "status": "resolved",
  "response": "Your issue has been resolved. The problem was related to account permissions.",
  "next_actions": ["Refresh your browser", "Log out and log back in"],
  "priority": "medium"
}
```

### Exemplo 2: Resposta de Análise de Dados

**Esquema:**

```json theme={null}
{
  "analysis": {
    "summary": "string",
    "findings": [
      {
        "category": "string",
        "insight": "string",
        "confidence": "number"
      }
    ],
    "recommendations": ["string"]
  },
  "data_points": "number"
}
```

**Resposta do Agente:**

```json theme={null}
{
  "analysis": {
    "summary": "Sales data shows 15% increase in Q4",
    "findings": [
      {
        "category": "revenue",
        "insight": "Revenue increased by 15% compared to Q3",
        "confidence": 0.95
      },
      {
        "category": "customers",
        "insight": "New customer acquisition up 20%",
        "confidence": 0.88
      }
    ],
    "recommendations": [
      "Continue current marketing strategy",
      "Focus on customer retention"
    ]
  },
  "data_points": 1250
}
```

### Exemplo 3: Resposta de Gestão de Tarefas

**Esquema:**

```json theme={null}
{
  "task": {
    "id": "string",
    "title": "string",
    "status": "todo|in_progress|completed",
    "assignee": "string",
    "due_date": "string",
    "description": "string"
  },
  "related_tasks": [
    {
      "id": "string",
      "title": "string"
    }
  ]
}
```

## Permissões

### Criando Saídas Estruturadas

* **Administrador do Projeto** - Pode criar, editar e excluir saídas estruturadas
* **Membro do Projeto** - Depende das permissões do projeto (flows.edit)
* **Visualizador** - Pode visualizar, mas não modificar saídas estruturadas

### Usando em Agentes

* **Proprietário do Agente** - Pode atribuir saídas estruturadas aos seus agentes
* **Administrador do Projeto** - Pode atribuir a qualquer agente no projeto
* **Membro do Projeto** - Pode atribuir a agentes que tenha acesso

## Recursos Relacionados

* **Configuração do Agente** - Configure a personalidade e o comportamento do agente
* **Ferramentas** - Use ferramentas que retornam dados estruturados
* **Integração de API** - Integre respostas estruturadas com APIs externas
* **Fluxos de Trabalho** - Use saídas estruturadas em fluxos de trabalho automatizados

<Card title="Configuração do Agente" icon="settings" href="/agents/agents">
  Saiba como configurar seus agentes
</Card>

## Suporte

Precisa de ajuda com saídas estruturadas? Entre em contato com o suporte em [support@automationanywhere.com](mailto:support@automationanywhere.com).