Agentes de 12 fatores 3. Assumindo o controle de sua janela de contexto

Você não é obrigado a usar um formato padronizado e baseado em mensagens para passar o contexto para o modelo de linguagem grande.

A qualquer momento, o input que você fornece ao grande modelo de linguagem nas inteligências de IA é "Aqui está tudo o que aconteceu até agora, aqui está o que fazer em seguida".

Tudo é engenharia contextual. Modelos de linguagem grandes são funções sem estadoEles convertem entradas em saídas. Para obter o melhor resultado, você precisa dar a eles o melhor input.

Criar um contexto de qualidade significa:

• Dicas e instruções que você fornece ao modelo
• Quaisquer documentos ou dados externos que você recupere (como RAG)
• Quaisquer estados anteriores, chamadas de ferramentas, resultados ou outros históricos
• Quaisquer notícias ou eventos passados de fontes relacionadas, mas independentes (memórias)
• Instruções sobre quais dados estruturados devem ser gerados

Sobre a engenharia contextual

O objetivo deste guia é explorar como maximizar o desempenho dos modelos atuais. É importante observar que este guia não menciona o seguinte:

• Alterações nos parâmetros do modelo, como temperatura, top_p, frequency_penalty, presence_penalty, etc.
• Treine seus próprios modelos complementares ou de incorporação
• Ajuste fino dos modelos existentes

Mais uma vez, não sei qual é a melhor maneira de passar o contexto para um modelo de linguagem grande, mas sei que você precisa ter flexibilidade para tentar todas as possibilidades.

Formatos de contexto padrão e personalizado

A maioria dos clientes do Big Language Model usa um formato padronizado e baseado em mensagens, conforme mostrado abaixo:

[
{
"role": "system",
"content": "你是一个乐于助人的助手..."
},
{
"role": "user",
"content": "你能部署后端吗？"
},
{
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "1",
"name": "list_git_tags",
"arguments": "{}"
}
]
},
{
"role": "tool",
"name": "list_git_tags",
"content": "{\"tags\": [{\"name\": \"v1.2.3\", \"commit\": \"abc123\", \"date\": \"2024-03-15T10:00:00Z\"}, {\"name\": \"v1.2.2\", \"commit\": \"def456\", \"date\": \"2024-03-14T15:30:00Z\"}, {\"name\": \"v1.2.1\", \"commit\": \"abe033d\", \"date\": \"2024-03-13T09:15:00Z\"}]}",
"tool_call_id": "1"
}
]

Embora essa abordagem funcione bem na maioria dos casos de uso, se você quiser realmente maximizar o desempenho dos grandes modelos de linguagem atuais, precisará fazer isso de uma forma que economize o máximo possível em Token e formas eficientes de atenção para inserir o contexto em um modelo de linguagem grande.

Como alternativa aos formatos padronizados e baseados em mensagens, você pode criar formatos de contexto personalizados otimizados para seus casos de uso. Por exemplo, você pode usar objetos personalizados e empacotá-los/espalhá-los em uma ou mais mensagens de usuário, sistema, auxiliar ou ferramenta, conforme necessário.

Esse é um exemplo de como colocar uma janela de contexto inteira em uma única mensagem de usuário:

[
{
"role": "system",
"content": "你是一个乐于助人的助手..."
},
{
"role": "user",
"content": |
这是目前为止发生的所有事情：
        
<slack_message>
来自: @alex
频道: #deployments
内容: 你能部署后端吗？
</slack_message>
<list_git_tags>
intent: "list_git_tags"
</list_git_tags>
<list_git_tags_result>
tags:
- name: "v1.2.3"
commit: "abc123"
date: "2024-03-15T10:00:00Z"
- name: "v1.2.2"
commit: "def456"
date: "2024-03-14T15:30:00Z"
- name: "v1.2.1"
commit: "ghi789"
date: "2024-03-13T09:15:00Z"
</list_git_tags_result>
下一步该怎么做？
}
]

O modelo pode deduzir, com base nos esquemas fornecidos, que você está solicitando what's the next stepmas não custa nada adicioná-lo explicitamente ao seu modelo de prompt.

exemplo de código

Podemos criá-lo com um código semelhante ao seguinte:

class Thread:
events: List[Event]
class Event:
# 可以只使用字符串，也可以是显式的 - 由你决定
type: Literal["list_git_tags", "deploy_backend", "deploy_frontend", "request_more_information", "done_for_now", "list_git_tags_result", "deploy_backend_result", "deploy_frontend_result", "request_more_information_result", "done_for_now_result", "error"]
data: ListGitTags | DeployBackend | DeployFrontend | RequestMoreInformation |  
ListGitTagsResult | DeployBackendResult | DeployFrontendResult | RequestMoreInformationResult | string
def event_to_prompt(event: Event) -> str:
data = event.data if isinstance(event.data, str) \
else stringifyToYaml(event.data)
return f"<{event.type}>\n{data}\n</{event.type}>"
def thread_to_prompt(thread: Thread) -> str:
return '\n\n'.join(event_to_prompt(event) for event in thread.events)

Exemplo de janela de contexto

Usando essa abordagem, a janela de contexto pode ter a seguinte aparência:

Solicitação inicial do Slack:

<slack_message>
来自: @alex
频道: #deployments
内容: 你能将最新的后端部署到生产环境吗？
</slack_message>

Depois de listar as tags do Git:

<slack_message>
来自: @alex
频道: #deployments
内容: 你能将最新的后端部署到生产环境吗？
Thread: []
</slack_message>
<list_git_tags>
intent: "list_git_tags"
</list_git_tags>
<list_git_tags_result>
tags:
- name: "v1.2.3"
commit: "abc123"
date: "2024-03-15T10:00:00Z"
- name: "v1.2.2"
commit: "def456"
date: "2024-03-14T15:30:00Z"
- name: "v1.2.1"
commit: "ghi789"
date: "2024-03-13T09:15:00Z"
</list_git_tags_result>

Erro e recuperação após:

<slack_message>
来自: @alex
频道: #deployments
内容: 你能将最新的后端部署到生产环境吗？
Thread: []
</slack_message>
<deploy_backend>
intent: "deploy_backend"
tag: "v1.2.3"
environment: "production"
</deploy_backend>
<error>
运行 deploy_backend 时出错: 连接部署服务失败
</error>
<request_more_information>
intent: "request_more_information_from_human"
问题: "我连接部署服务时遇到问题，你能提供更多详细信息和/或检查一下该服务的状态吗？"
</request_more_information>
<human_response>
data:
回复: "我不确定发生了什么，你能检查一下最新工作流的状态吗？"
</human_response>

A partir daí, sua próxima etapa pode ser:

nextStep = await determine_next_step(thread_to_prompt(thread))

{
"intent": "get_workflow_status",
"workflow_name": "tag_push_prod.yaml",
}

Esse formato semelhante ao XML é apenas um exemplo - a questão é que você pode criar formatos personalizados que se ajustem ao seu aplicativo. Se você tiver flexibilidade para experimentar diferentes estruturas de contexto, bem como decidir o que armazenar e o que passar para o modelo de linguagem mais amplo, obterá melhor qualidade.

O principal benefício de estar no controle da sua janela de contexto:

1. densidade de informaçõesOrganização de informações de forma a maximizar a compreensão de modelos de linguagem grandes
2. Tratamento de errosInclua mensagens de erro em um formato que ajude na recuperação de grandes modelos de linguagem. Quando os erros e as chamadas com falha forem resolvidos, considere a possibilidade de ocultá-los da janela de contexto.
3. segurançaControle as informações passadas para o Big Language Model, filtrando dados confidenciais
4. destrezaAjuste o formato à medida que você aprende sobre as práticas recomendadas de casos de uso
5. Eficiência do tokenTradução: Otimização de formatos de contexto para eficiência de token e compreensão de modelos de idiomas grandes

O contexto inclui: prompts, comandos, documentos RAG, histórico, chamadas de ferramentas, memória

Lembre-se: a janela de contexto é sua interface principal para interagir com o modelo de linguagem mais amplo. Assumir o controle da maneira como você organiza e apresenta as informações pode melhorar significativamente o desempenho de suas inteligências.

Exemplo - Densidade da mensagem - mesma mensagem, menos tokens:

Não acredite em minha palavra.

Cerca de dois meses após o lançamento do 12-Factor Agents, a engenharia de contexto começou a se tornar um termo bastante popular.

Além disso.@lenadroid Em julho de 2025, também foi lançado um Tabela de referência rápida de engenharia contextual.

O tema recorrente aqui é que eu não sei qual é a melhor abordagem, mas sei que você precisa ter flexibilidade para poder experimentar todas as possibilidades.