Agno a évolué rapidement vers une gamme de produits de production AgentOS— un environnement d'exécution, un framework et un plan de contrôle pour les systèmes multi-agents — tandis que CometAPI (l'agrégateur « tous les modèles dans une seule API ») a annoncé officiellement sa prise en charge en tant que fournisseur de modèles pour Agno. Ensemble, ils simplifient l'exécution de systèmes multi-agents capables de basculer entre des centaines de points de terminaison de modèles sans réécrire le code de l'agent. L'utilisation de passerelles unifiées comme CometAPI comme fournisseurs de modèles intégrés pour les frameworks d'agents tels qu'Agno est donc une demande. Le modèle décrit ci-dessous est donc à la fois pratique et opportun.
Que sont exactement Agno et CometAPI ?
Qu'est-ce qu'Agno et pourquoi devrais-je m'en soucier ?
Agno est un framework multi-agents Pythonique hautes performances, avec environnement d'exécution et interface utilisateur, conçu pour composer des agents, des équipes et des workflows agentiques avec de la mémoire, des outils, des connaissances et une assistance humaine. Il fournit un environnement d'exécution FastAPI (AgentOS), des outils de développement local et une interface utilisateur de plan de contrôle pour tester et surveiller les agents en cours d'exécution sans transférer de données hors de votre environnement. Si vous souhaitez créer rapidement des systèmes d'agents de niveau production tout en gardant le contrôle total des données et de l'observabilité, Agno est la solution idéale.
Qu'est-ce que CometAPI et pourquoi l'utiliserais-je comme fournisseur LLM ?
CometAPI est un agrégateur d'API/passerelle de modèles offrant une API unique et cohérente à des dizaines, voire des centaines, de LLM et de modalités (texte, images, vidéo, etc.). Au lieu de se limiter à un seul fournisseur de modèles, les développeurs font appel à la passerelle CometAPI et peuvent changer de fournisseur ou de modèle via des paramètres, ce qui est utile pour la gestion des coûts, les tests A/B et les solutions de secours. La plateforme prend en charge le basculement entre les modèles, la facturation unifiée et revendique des points de terminaison compatibles OpenAI. Autrement dit, vous pouvez souvent pointer un client OpenAI vers l'URL de base et le jeton d'authentification de CometAPI et appeler des modèles comme s'il s'agissait de points de terminaison OpenAI. CometAPI est donc un fournisseur direct et pratique pour les frameworks qui utilisent déjà l'interface API OpenAI.
Signal récent : CometAPI a été annoncé comme fournisseur de modèles en Documents officiels d'Agno et les chaînes communautaires, ce qui signifie qu'Agno expédie une CometAPI classe de fournisseur de modèle que vous pouvez transmettre à votre Agent. Cela rend l'intégration de la passerelle simple et prise en charge.
Pourquoi intégrer Agno avec CometAPI ?
- Pas de dépendance vis-à-vis d'un fournisseurCometAPI vous permet d'expérimenter avec de nombreux modèles (OpenAI, Claude, variantes de LLama, Gemini, etc.) sans changer de SDK. Cela complète la conception indépendante des modèles d'Agno.
- Boucle de développement plus rapide:Étant donné que CometAPI prend en charge les points de terminaison de style OpenAI, vous éviterez souvent d'écrire un fournisseur Agno personnalisé : vous pouvez pointer l'adaptateur de modèle OpenAI d'Agno vers CometAPI et démarrer.
- Observabilité + contrôle:Utilisez le runtime et le plan de contrôle AgentOS d'Agno pour exécuter des agents localement ou dans votre cloud tout en composant des modèles via CometAPI, combinant le meilleur de la flexibilité du modèle et de l'observabilité de l'exécution.
Comment intégrer Agno avec CometAPI étape par étape ?
Vous trouverez ci-dessous un flux de travail pratique et copiable-collable, depuis la création d'un environnement virtuel jusqu'à l'exécution d'une instance AgentOS locale qui appelle des modèles via CometAPI.
Idée clé : Étant donné que CometAPI expose un point de terminaison compatible OpenAI, l'approche la plus simple consiste à utiliser l'adaptateur de modèle OpenAI d'Agno et à pointer
OPENAI_API_BASE(ouopenai.api_base) à l'URL de base de CometAPI, tout en fournissant votre jeton CometAPI comme clé API OpenAI. CometAPI documente explicitement ce flux « modifier l'URL de base et utiliser le format OpenAI ».
Environnement et prérequis dont vous avez besoin avant de commencer
Quel système d’exploitation, quelle version Python et quels outils sont recommandés ?
- OS: macOS, Linux ou Windows — Agno et les outils prennent en charge les trois. ()
- python: Utilisez un CPython moderne (la documentation et le dépôt d'Agno ciblent les versions modernes de Python ; il est recommandé d'utiliser Python 3.12). Consultez le dépôt et la documentation d'Agno pour une compatibilité exacte avant tout déploiement en production.
- Gestionnaire de paquets / virtualenv :
uv(l'Astraluv(projet) est une excellente option rapide pour gérer les environnements virtuels et les dépendances.
Quels comptes, clés et prérequis réseau devez-vous préparer ?
- Compte CometAPI et clé API. Récupérez votre clé depuis CometAPI et stockez-la dans une variable d'environnement (
COMETAPI_KEY). L'adaptateur de modèle CometAPI d'Agno litCOMETAPI_KEY. - Compte de plan de contrôle Agno facultatif (interface utilisateur AgentOS). Si vous prévoyez de connecter un AgentOS local au plan de contrôle pour des fonctionnalités de surveillance ou d'équipe, préparez votre accès au plan de contrôle et vos autorisations d'organisation/d'équipe.
- Base de données pour l'état de l'agent (facultatif). Pour la persistance, vous configurerez généralement SQLite/Postgres en fonction de l'échelle ; Agno a des exemples montrant Sqlite pour le développement local.
Comment intégrer Agno avec CometAPI étape par étape ?
Vous trouverez ci-dessous un flux de travail pratique et copiable-collable, depuis la création d'un environnement virtuel jusqu'à l'exécution d'une instance AgentOS locale qui appelle des modèles via CometAPI.
Idée clé : Étant donné que CometAPI expose un point de terminaison compatible OpenAI, l'approche la plus simple consiste à utiliser l'adaptateur de modèle OpenAI d'Agno et à pointer
OPENAI_API_BASE(ouopenai.api_base) à l'URL de base de CometAPI, tout en fournissant votre jeton CometAPI comme clé API OpenAI. CometAPI documente explicitement ce flux « modifier l'URL de base et utiliser le format OpenAI ».
1) Installer uv et créer l'environnement virtuel
uv installateur (une ligne) :
# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
Créez et activez un venv reproductible (le démarrage rapide d'Agno utilise Python 3.12) :
# create a venv managed by uv
uv venv --python 3.12
# activate (POSIX)
source .venv/bin/activate
(Si vous préférez le traditionnel python -m venv .venv ça marche aussi; uv (offre des avantages en termes de fichier de verrouillage et de reproductibilité.)
2) Installez Agno et les dépendances d'exécution (via uv pip)
```bash
uv pip install -U agno openai mcp 'fastapi' sqlalchemy 'httpx'
# optionally, add extras you need
uv pip install -U agno # if using cloud infra plugins
(installez les autres bibliothèques dont vous avez besoin : clients de base de données vectorielles, bibliothèques de surveillance, etc.)
Agno installe généralement `agno` + SDK fournisseurs.
### 3) Exporter la clé API CometAPI
Définissez la variable d'environnement que le fournisseur Agno Comet lira :
bash
macOS / Linux
export COMETAPI_KEY="sk-xxxx-your-cometapi-key"
Windows (PowerShell)
setx COMETAPI_KEY "sk-xxxx-your-cometapi-key"
Le fournisseur CometAPI d'Agno est par défaut en lecture `COMETAPI_KEY`.
### 4) Créez un petit agent Agno qui utilise le fournisseur CometAPI
Ouvrez le dossier et créez un nouveau fichier. Enregistrez-le ci-dessous sous `comet_agno_agent.py`:
from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.models.cometapi import CometAPI
from agno.os import AgentOS
from agno.tools.mcp import MCPTools
1) Create an Agent which uses CometAPI as the model provider
id parameter selects a model id from the CometAPI catalog
agno_agent = Agent(
name="Agno Agent",
model=CometAPI(id="gpt-5-mini"),
# Add a database to the Agent
db=SqliteDb(db_file="agno.db"),
# Add the Agno MCP server to the Agent
tools=,
# Add the previous session history to the context
add_history_to_context=True,
markdown=True,
)
2) Attach Agent to AgentOS and get FastAPI app
agent_os = AgentOS(agents=)
Get the FastAPI app for the AgentOS
app = agent_os.get_app()
### 5) Exécutez Agno localement pour tester
Démarrez le serveur de développement AgentOS (FastAPI) :
In the activated .venv (uv-managed)
fastapi dev agno_comet_agent.py
defaults to http://localhost:8000
Open `http://localhost:8000/docs` pour inspecter les points de terminaison générés automatiquement.
> Assurez-vous que les variables d'environnement sont définies (COMETAPI\_KEY\_API\_KEY)
### 6) Connectez votre AgentOS local au plan de contrôle AgentOS (facultatif)
Si vous souhaitez que le plan de contrôle Web Agno surveille votre AgentOS local :
1. Visitez le plan de contrôle AgentOS : `os.agno.com` et connectez-vous.
2. Cliquez sur **Ajouter un nouveau système d'exploitation → Local**, Entrer `http://localhost:8000`, donnez-lui un nom, et **Se connectez**.
Une fois connecté, vous obtenez l'interface Web pour le chat, les sessions, les métriques et la gestion.
## Quelles sont les meilleures pratiques de configuration et de sécurité ?
### Secrets et clés API
Ne validez jamais les clés API. Utilisez des variables d'environnement, un gestionnaire de secrets ou `.env` combiné avec les locaux `.gitignore`Bonne pratique : effectuez une rotation régulière des clés et limitez leur utilisation par adresse IP si le fournisseur le permet. (La documentation OpenAI et d'autres fournisseurs recommandent les variables d'environnement.)
### Sélection du modèle et contrôle des coûts
Utilisez le catalogue de modèles de CometAPI pour choisir des modèles présentant un compromis coût/latence adapté. Définissez des limites de débit raisonnables et implémentez des tentatives avec un recul exponentiel. CometAPI expose les listes de modèles et leurs tarifs dans sa documentation.
### Observabilité
Utilisez le plan de contrôle AgentOS d'Agno pour les journaux des agents, les traces de session et les métriques. Combinez-le avec les métriques du fournisseur (tableau de bord CometAPI) pour corréler les coûts/latences avec l'activité des agents.
### Confidentialité et résidence des données
Comme AgentOS s'exécute dans votre cloud, vous gardez le contrôle des données de session. Cependant, évitez de transmettre des informations personnelles sensibles à des modèles tiers, sauf autorisation explicite de votre politique ; si nécessaire, utilisez un hébergement de modèles sur site ou privé.
## Quelles sont les meilleures pratiques et les cas d’utilisation recommandés ?
### des pratiques d’excellence;
- **Commencer petit:** tester avec un agent de développement et un modèle de bas niveau (moins cher) avant la mise à l'échelle.
- **Modèle de repli :** Implémenter une chaîne de secours (par exemple, modèle compact et moins cher → modèle plus performant en cas de panne). CometAPI facilite le changement de modèle par nom.
- **Outillage à grain fin :** Offrez aux agents des outils limités et audités (recherche web, accès aux bases de données) et instrumentez les appels d'outils avec des traces. Agno fournit des intégrations d'outils et un modèle pour les appels instrumentés.
- **Limitation de débit et traitement par lots :** Regroupez les demandes similaires et appliquez des limites de débit au niveau de la passerelle ou du client pour éviter les surtensions.
### Cas d'utilisation typiques
- **Chatbots RAG (Récupération-Génération Augmentée)** — Agents Agno pour les documents + CometAPI pour la génération de langage.
- **Flux de travail automatisés** — des flux de travail multi-agents qui combinent des outils de scraping Web, des bases de données vectorielles et des étapes génératives.
- **Du prototype à la production** — itérez rapidement en utilisant CometAPI pour essayer différents modèles, puis épinglez le fournisseur choisi ou passez à un contrat d'entreprise.
## Comment démarrer avec l'API Comet
CometAPI est une plateforme d'API unifiée qui regroupe plus de 500 modèles d'IA provenant de fournisseurs leaders, tels que la série GPT d'OpenAI, Gemini de Google, Claude d'Anthropic, Midjourney, Suno, etc., au sein d'une interface unique et conviviale pour les développeurs. En offrant une authentification, un formatage des requêtes et une gestion des réponses cohérents, CometAPI simplifie considérablement l'intégration des fonctionnalités d'IA dans vos applications. Que vous développiez des chatbots, des générateurs d'images, des compositeurs de musique ou des pipelines d'analyse pilotés par les données, CometAPI vous permet d'itérer plus rapidement, de maîtriser les coûts et de rester indépendant des fournisseurs, tout en exploitant les dernières avancées de l'écosystème de l'IA.
Pour commencer, explorez les capacités du modèle de [API Comet](https://www.cometapi.com/fr/?utm_source=agno uted) dans le [cour de récréation](https://www.cometapi.com/console/playground) et consultez le Continuer [Guide de l'API](https://apidoc.cometapi.com/continue-1624859m0) Pour des instructions détaillées, veuillez vous connecter à CometAPI et obtenir la clé API avant d'y accéder. [Avec](https://www.cometapi.com/fr/)[e](https://www.cometapi.com/fr/?utm_source=agno uted)[tAPI](https://www.cometapi.com/fr/) proposer un prix bien inférieur au prix officiel pour vous aider à vous intégrer.
Prêt à partir ?→ [Inscrivez-vous à CometAPI dès aujourd'hui](https://api.cometapi.com/login) !
Si vous souhaitez connaître plus de conseils, de guides et d'actualités sur l'IA, suivez-nous sur [VK](https://vk.com/id1078176061), [X](https://x.com/cometapi2025) et [Discord](https://discord.com/invite/HMpuV6FCrG)!
## Réflexions finales
L'intégration d'Agno avec CometAPI vous offre une solution pragmatique pour créer des systèmes agentiques flexibles, observables et indépendants des fournisseurs. Agno fournit l'environnement d'exécution et le plan de contrôle ; CometAPI offre une passerelle unique vers de nombreux modèles. Ensemble, ils réduisent les frictions opérationnelles : moins de contraintes pour chaque agent, une expérimentation simplifiée et une facturation et des contrôles centralisés.