Fast-Agent: gramática declarativa e integração de MCP para criar rapidamente fluxos de trabalho corporais multiinteligentes

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.

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:

1. 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 --version

2. 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]

3. 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:

fast-agent setup

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

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

fast-agent --version

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

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

import asyncio
from mcp_agent.core.fastagent import FastAgent
fast = FastAgent("Simple Agent")
@fast.agent(instruction="Given an object, respond with its estimated size.")
async def main():
async with fast.run() as agent:
await agent()
if __name__ == "__main__":
asyncio.run(main())

2. 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.

3. Especificação de modelos
   fazer uso de --model Modelo de seleção de parâmetros:

   uv run agent.py --model=o3-mini.low
   

Criação de fluxos de trabalho

1. Gerar modelos de fluxo de trabalho
   fazer uso de bootstrap para gerar exemplos:

   fast-agent bootstrap workflow
   

   Isso criará um catálogo de fluxos de trabalho encadeados que mostram como desenvolver inteligências eficazes.

2. 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 chaining.pyDefina fluxos de trabalho encadeados:

  @fast.agent("url_fetcher", "Given a URL, provide a summary", servers=["fetch"])
  @fast.agent("social_media", "Write a 280 character post for the text.")
  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", "Translate to French")
  @fast.agent("translate_de", "Translate to German")
  @fast.parallel(name="translate", fan_out=["translate_fr", "translate_de"])
  async 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="Assist with tasks, request human input if needed.", human_input=True)
  async def main():
  async with fast.run() as agent:
  await agent.send("print the next number in the sequence")
  

  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:

  fast-agent bootstrap researcher
  

  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:

servers:
fetch:
type: "fetch"
endpoint: "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:

1. estar em movimento fast-agent bootstrap workflow Gerar modelos.
2. compilador chaining.pySe quiser configurar o URL e o servidor MCP, você poderá fazê-lo clicando no botão "Setup" (Configuração).
3. realizar uv run chaining.pyPara visualizar a postagem de 280 caracteres gerada.
4. fazer uso de --quiet 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.