Fast-Agent : grammaire déclarative et intégration MCP pour la construction rapide de flux de travail multi-intelligents pour le corps humain

Dernières ressources sur l'IAPosté il y a 7 mois Cercle de partage de l'IA

Introduction générale

Fast-Agent est un outil open source maintenu par l'équipe d'evalstate sur GitHub, conçu pour aider les développeurs à définir, tester et construire rapidement des workflows corporels multi-intelligents. Basé sur une syntaxe déclarative simple, il supporte l'intégration avec les serveurs MCP (Model-Compute-Platform), permettant aux utilisateurs de se concentrer sur la conception des invites et de la logique d'intelligence au lieu d'une configuration fastidieuse. fast-Agent offre de multiples modes de flux de travail (par exemple, enchaîné, parallèle, optimisé pour l'évaluation, etc.), une instrumentation de ligne de commande intégrée (CLI), et une fonction de chat interactive, ce qui le rend adapté aux scénarios de développement allant du prototypage au déploiement de la production. Il convient donc à des scénarios de développement allant du prototypage au déploiement en production. Le projet est placé sous la licence Apache 2.0 et soutient les contributions de la communauté en mettant l'accent sur la facilité d'utilisation et la flexibilité.

Liste des fonctions

Définition du corps intelligent: définition rapide des intelligences à l'aide de simples décorateurs, prise en charge des directives personnalisées et de l'utilisation de la technologie de l'information dans le domaine de la santé. MCP Appel du serveur.
Construction du flux de travailIl prend en charge plusieurs modes de flux de travail tels que la chaîne, le parallèle, l'évaluateur-optimisateur, le routeur et l'orchestrateur.
Sélection du modèleLes modèles d'ordinateurs : Passez facilement d'un modèle à l'autre (par exemple, o3-mini, sonnet) et testez l'interaction entre le modèle et le serveur MCP.
chat interactifLe système de gestion de l'information est un outil qui permet de dialoguer en temps réel avec des intelligences individuelles ou des composants de flux de travail afin de faciliter le débogage et l'optimisation.
Soutien aux testsLes capacités de test intégrées pour valider la performance des intelligences et des flux de travail, adaptées à l'intégration dans les processus d'intégration continue (CI).
Fonctionnement du CLILe logiciel de gestion de l'interface utilisateur : fournit des outils en ligne de commande pour simplifier l'installation, l'exécution et le débogage du logiciel.
apport humainL'Intelligentsia peut demander à l'homme de lui fournir un contexte supplémentaire pour mener à bien ses tâches.
Prototypage rapideLe système d'information sur le corps humain : De la simple configuration du fichier à l'exécution, il ne faut que quelques minutes pour lancer une application sur le corps humain.

Utiliser l'aide

L'objectif principal de Fast-Agent est d'abaisser les barrières au développement du multi-intelligence. Vous trouverez ci-dessous des guides d'installation et d'utilisation détaillés afin d'aider les utilisateurs à être rapidement opérationnels et à maîtriser ses fonctionnalités.

Processus d'installation

Fast-Agent dépend de l'environnement Python, il est recommandé d'utiliser l'option uv Package Manager. Les étapes de l'installation sont les suivantes :

Installation de Python et d'uv
Assurez-vous que Python 3.9 ou une version plus récente est installé sur votre système, puis installez l'extension uv: :

pip install uv

Vérifier l'installation :

uv --version

Installation de Fast-Agent
faire passer (un projet de loi, une inspection, etc.) uv Installé depuis PyPI :

uv pip install fast-agent-mcp

Pour une prise en charge complète des fonctionnalités (par exemple, système de fichiers ou serveur Docker MCP), exécutez :

uv pip install fast-agent-mcp[full]

Initialisation Configuration
Une fois l'installation terminée, des exemples de fichiers de configuration et d'intelligences sont générés :

fast-agent setup

Cette opération génère le agent.py répondre en chantant fastagent.config.yaml etc.

Vérifier l'installation
Vérifier la version :

fast-agent --version

Si le numéro de version est renvoyé, l'installation a réussi.

Utilisation

Fast-Agent permet d'exécuter des intelligences et des flux de travail à partir de la ligne de commande ou du code, comme décrit ci-dessous.

Créer et exploiter les intelligences de base

Définir l'intelligence
compilateur agent.py, en ajoutant les intelligences 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())

Running Intelligence
Exécutez-le à partir de la ligne de commande :
```
uv run agent.py
```
Cette opération lance un mode de discussion interactif, dans lequel le nom de l'objet (par exemple, "la lune") est saisi et l'intelligence renvoie une estimation de la taille de l'objet.
Spécification des modèles
utiliser --model Modèle de sélection des paramètres :
```
uv run agent.py --model=o3-mini.low
```

Création de flux de travail

Générer des modèles de flux de travail
utiliser bootstrap pour générer des exemples :
```
fast-agent bootstrap workflow
```
Cela permettra de créer un catalogue de flux de travail enchaînés montrant comment construire des intelligences efficaces.
Exécution de flux de travail
Allez dans le répertoire du flux de travail généré et exécutez :
```
uv run chaining.py
```
Le système récupère le contenu de l'URL spécifiée et génère des messages pour les médias sociaux.

Fonction en vedette Fonctionnement

Chaîne de travail (Chaîne)
compilateur chaining.pydéfinir des flux de travail enchaînés :

@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)

configurer fastagent.config.yaml Après avoir exécuté le serveur MCP dans le :

uv run chaining.py

Flux de travail parallèle (Parallel)
Définir un flux de travail de traduction multilingue :

@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!")

Une fois exécuté, le texte sera traduit en français et en allemand.

apport humain
Définir les intelligences qui nécessitent une intervention humaine :

@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")

Lors de l'exécution, l'utilisateur sera invité à saisir davantage d'informations si le renseignement le nécessite.

Evaluator-Optimizer (Evaluateur-Optimiseur)
Générer un flux de travail de recherche :
```
fast-agent bootstrap researcher
```
Modifiez le profil et lancez-le, l'intelligence générera le contenu et l'optimisera jusqu'à ce que vous soyez satisfait.

Configuration du serveur MCP

compilateur fastagent.config.yaml, ajoutez le serveur :

servers:
fetch:
type: "fetch"
endpoint: "https://api.example.com"

Au moment de l'exécution, l'organisme intelligent appellera ce serveur pour obtenir des données.

Exemple de déroulement des opérations

Supposons que vous ayez besoin de générer des messages sur les médias sociaux à partir d'URL :

être en mouvement fast-agent bootstrap workflow Générer des modèles.
compilateur chaining.pySi vous souhaitez configurer l'URL et le serveur MCP, vous pouvez le faire en cliquant sur le bouton "Setup".
réaliser uv run chaining.pyPour afficher le message de 280 caractères généré.
utiliser --quiet ne renvoie que le résultat :
```
uv run chaining.py --quiet
```

mise en garde

Utilisateur WindowsLa configuration du système de fichiers et du serveur Docker MCP doit être ajustée, comme décrit dans la note Generate Configuration File (Générer un fichier de configuration).
ajuster les composants pendant les essaisSi l'exécution échoue, ajouter --verbose Afficher les journaux détaillés :
```
uv run agent.py --verbose
```

Grâce à ces étapes, les utilisateurs peuvent rapidement installer et utiliser Fast-Agent pour créer et tester des flux de travail multi-intelligence pour des scénarios de recherche, de développement et de production.