Fast-Agent: gramática declarativa e integração de MCP para a construção rápida de fluxos de trabalho de corpo multiinteligente

🚀 Convite para experimentar: o primeiro software de programação inteligente AI IDE da China Download da versão chinesa do TraeO DeepSeek-R1 e o Doubao-pro estão disponíveis em uma base ilimitada!

Introdução geral

O Fast-Agent é uma ferramenta de código aberto mantida pela equipe do evalstate no GitHub, projetada para ajudar os desenvolvedores a definir, testar e criar rapidamente fluxos de trabalho corporais com várias inteligências. Com base em uma sintaxe declarativa simples, ele oferece suporte à integração com servidores MCP (Model-Compute-Platform), permitindo que os usuários se concentrem no design de prompts e na lógica de inteligência, em vez de configurações tediosas. O fast-Agent oferece vários modos de fluxo de trabalho (por exemplo, encadeado, paralelo, otimizado para avaliação etc.), uma CLI (Command Line Instrumentation, Instrumentação de linha de comando) integrada e um recurso de bate-papo interativo, tornando-o adequado para cenários de desenvolvimento que vão desde a prototipagem até a implantação da produção. Ele é adequado para cenários de desenvolvimento que vão desde a criação de protótipos até a implantação da produção. O projeto está licenciado sob a licença Apache 2.0 e apóia contribuições da comunidade com ênfase na facilidade de uso e na flexibilidade.

Fast-Agent: gramática declarativa e integração de MCP para construção rápida de fluxos de trabalho corporais multiinteligentes-1

Lista de funções

Definição de Intelligent Body (Corpo Inteligente)Definição rápida de inteligências por meio de decoradores simples, suporte para diretivas personalizadas e MCP Chamada do servidor.
Construção do fluxo de trabalhoEle oferece suporte a vários modos de fluxo de trabalho, como Chain, Parallel, Evaluator-Optimizer, Router e Orchestrator.
Seleção de modelosIntercâmbio fácil entre diferentes modelos (por exemplo, o3-mini, sonnet) e teste a interação entre o modelo e o servidor MCP.
bate-papo interativoSuporte ao diálogo em tempo real com inteligências individuais ou componentes de fluxo de trabalho para facilitar a depuração e a otimização.
Suporte a testesRecursos de teste incorporados para validar o desempenho de inteligências e fluxos de trabalho, adequados para integração em processos de integração contínua (CI).
Operação da CLILinha de comando: fornece ferramentas de linha de comando para simplificar a instalação, o tempo de execução e o processo de depuração.
contribuição humanaA Intelligentsia pode solicitar a participação humana para fornecer contexto adicional para a conclusão de tarefas.
Prototipagem rápidaDesde a configuração simples do arquivo até a execução, são necessários apenas alguns minutos para iniciar um aplicativo de corpo inteligente.

Usando a Ajuda

O objetivo principal do Fast-Agent é reduzir as barreiras para o desenvolvimento de várias inteligências. Abaixo estão guias detalhados de instalação e uso para ajudar os usuários a começar a trabalhar rapidamente e a dominar seus recursos.

Processo de instalação

O Fast-Agent depende do ambiente Python, e é recomendável usar o parâmetro uv Gerenciador de pacotes. Veja a seguir as etapas de instalação:

Instalação do Python e do uv
Certifique-se de que o Python 3.9 ou posterior esteja instalado em seu sistema e, em seguida, instale o pacote uv::

pip install uv

Verifique a instalação:

uv --versão

Instalação do Fast-Agent
aprovar (um projeto de lei ou inspeção etc.) uv Instalado a partir do PyPI:

uv pip install fast-agent-mcp

Para obter suporte completo a recursos (por exemplo, sistema de arquivos ou servidor Docker MCP), execute:

uv pip install fast-agent-mcp[full]

Configuração de inicialização
Após a conclusão da instalação, são gerados arquivos de configuração e inteligências de amostra:

configuração de agente rápido

Isso gerará o agente.py responder cantando fastagent.config.yaml etc.

Verificar a instalação
Verifique a versão:

fast-agent --versão

Se o número da versão for retornado, a instalação foi bem-sucedida.

Uso

O Fast-Agent suporta a execução de inteligências e fluxos de trabalho a partir da linha de comando ou do código, conforme descrito abaixo.

Criação e execução de inteligências básicas

Definição de inteligência
compilador agente.py, acrescentando inteligências simples:

importar asyncio
from mcp_agent.core.fastagent import FastAgent
fast = FastAgent("Agente simples")
@fast.agent(instruction="Dado um objeto, responda com seu tamanho estimado.")
async def main(): async with fast.run()
async with fast.run() as agent.
await agent()
se __name__ == "__main__".
asyncio.run(main())

Inteligência de corrida
Execute-o na linha de comando:
```
uv run agent.py
```
Isso iniciará um modo de bate-papo interativo, no qual o nome do objeto (por exemplo, "a lua") é inserido e o smart retornará uma estimativa do tamanho.
Especificação de modelos
fazer uso de ---modelo Modelo de seleção de parâmetros:
```
uv run agent.py --model=o3-mini.low
```

Criação de fluxos de trabalho

Gerar modelos de fluxo de trabalho
fazer uso de bootstrap para gerar exemplos:
```
bootstrap de agente rápido fluxo de trabalho
```
Isso criará um catálogo de fluxos de trabalho encadeados que mostram como desenvolver inteligências eficazes.
Execução de fluxos de trabalho
Vá para o diretório do fluxo de trabalho gerado e execute-o:
```
uv run chaining.py
```
O sistema buscará o conteúdo do URL especificado e gerará publicações em mídias sociais.

Operação da função em destaque

Fluxo de trabalho em cadeia (cadeia)
compilador encadeamento.pyDefina fluxos de trabalho encadeados:

@fast.agent("url_fetcher", "Dado um URL, forneça um resumo", servers=["fetch"])
@fast.agent("social_media", "Escreva uma postagem de 280 caracteres para o texto.")
async def main():
async with fast.run() as agent.
result = await agent.social_media(await agent.url_fetcher("http://example.com"))
print(result)

configurar fastagent.config.yaml Depois de executar o servidor MCP no modo:

uv run chaining.py

Fluxo de trabalho paralelo (Paralelo)
Defina um fluxo de trabalho de tradução multilíngue:

@fast.agent("translate_fr", "Traduzir para o francês")
@fast.agent("translate_de", "Traduzir para o alemão")
@fast.parallel(name="translate", fan_out=["translate_fr", "translate_de"])
assíncrono def main().
async with fast.run() as agent.
await agent.translate.send("Hello, world!")

Uma vez executado, o texto será traduzido para o francês e o alemão.

contribuição humana
Defina as inteligências que requerem a participação humana:

@fast.agent(instruction="Ajudar com as tarefas, solicitar a participação humana se necessário.", human_input=True)
async def main():
async with fast.run() as agent.
await agent.send("imprime o próximo número na sequência")

Durante a execução, o usuário será solicitado a inserir mais informações se o smart exigir.

Evaluator-Optimizer (Avaliador-otimizador)
Gerar um fluxo de trabalho de pesquisa:
```
pesquisador de bootstrap de agente rápido
```
Edite o perfil e execute-o. A inteligência gerará o conteúdo e o otimizará até que você esteja satisfeito.

Configuração do servidor MCP

compilador fastagent.config.yaml, adicione o servidor:

servidores.
fetch.
tipo: "fetch"
ponto de extremidade: "https://api.example.com"

Em tempo de execução, o corpo inteligente chamará esse servidor para obter dados.

Exemplo de fluxo de operação

Suponha que você precise gerar posts de mídia social a partir de URLs:

estar em movimento fluxo de trabalho de bootstrap de agente rápido Gerar modelos.
compilador encadeamento.pySe quiser configurar o URL e o servidor MCP, você poderá fazê-lo clicando no botão "Setup" (Configuração).
realizar uv run chaining.pyPara visualizar a postagem de 280 caracteres gerada.
fazer uso de --Silencioso retorna apenas o resultado:
```
uv run chaining.py --quiet
```

advertência

Usuário do WindowsConfiguração do sistema de arquivos e do servidor Docker MCP: O sistema de arquivos e a configuração do servidor Docker MCP precisam ser ajustados, conforme descrito na nota Gerar arquivo de configuração.
ajustar os componentes durante o testeSe a execução falhar, adicione --verbose Veja os registros detalhados:
```
uv run agent.py --verbose
```

Com essas etapas, os usuários podem instalar e usar rapidamente o Fast-Agent para criar e testar fluxos de trabalho de inteligência múltipla para cenários de pesquisa, desenvolvimento e produção.