Choisissez votre plan
Mises à jour de modèles, guides API, benchmarks et informations pratiques pour développer plus rapidement avec CometAPI.
Configurer l’API Gemini 4 Carbon avec CometAPI. Suivre les exemples Python et REST, valider les réponses, analyser des PDF et des images, et gérer le streaming.
Utilisez FLUX 3 Image sur CometAPI pour la génération et la retouche. Découvrez les paramètres d’image, la gestion des tâches asynchrones, des exemples de prompts et les tarifs.
Apprenez l'API Claude Fable 5.2 avec la configuration officielle d'Anthropic et de CometAPI, des exemples en Python, le streaming, l'entrée d'image, la tarification et les bonnes pratiques de production
Apprenez à auto-héberger Kimi K3.1 Pro avec vLLM, à vérifier les exigences en matière de GPU, à télécharger les poids du modèle, à tester l’inférence et à comparer le déploiement local à l’accès via API.
Découvrez ce qu’est OpenAI Agents API, comment elle fonctionne, ses fonctionnalités, sa tarification, des exemples de code, des cas d’utilisation concrets et des alternatives.
Ajoutez la vision à un agent d'IA avec Python et CometAPI. Validez les images, analysez les observations structurées et dirigez les résultats incertains vers un examen.
Apprenez les flux de travail de l'API GPT Image 2.6 avec CometAPI : génération de SVG, PNG transparents, édition multi-images, balisage, paramètres, tarification et migration.
Apprenez à créer des GIF avec GPT Image 2.6 dans ChatGPT, à rédiger de meilleurs prompts et à accéder à Flare et Sunburst via CometAPI pour vos applications.
Comparaison entre MCP et l’appel de fonctions - Appel de fonctions (function calling): - Intégration étroite: les fonctions vivent dans le même runtime que le modèle et sont appelées via des “tool calls” propriétaires. - Découverte limitée: pas de protocole standard pour lister, négocier ou versionner des outils; dépend des conventions de l’implémentation. - Couplage fort: sécurité, permissions, et contexte sont gérés au cas par cas; difficile à partager entre modèles/clients. - Transport implicite: pas de canal standard pour la communication; souvent spécifique à un fournisseur. - MCP (Model Context Protocol): - Standardisation: protocole normalisé pour exposer des outils, ressources et prompts avec schémas, capacités et négociation. - Découplage: serveur d’outils séparé, réutilisable par plusieurs clients et modèles; meilleure observabilité et gouvernance. - Découverte et schémas: outils listés, descriptions et schémas d’entrées/sorties publiés; validation systématique. - Transports variés: prise en charge de stdio, sockets, etc., avec sessions, permissions et flux structurés. Code Python: boucle d’outil complète CometAPI, exécution directe et via MCP comet_api.py ```python # comet_api.py # API Comet simulée pour la recherche de commandes. # Dans un cas réel, remplacez la logique par des appels HTTP (requests) vers votre service Comet. from __future__ import annotations import datetime import random from typing import Dict, Any, List class CometAPI: def __init__(self, api_key: str, base_url: str = "https://api.comet.example"): # Stocke les paramètres d’accès (dans la vraie vie, vérifiez la clé, gérez la rotation, etc.) self.api_key = api_key self.base_url = base_url def get_order(self, order_id: str) -> Dict[str, Any]: # Simule une recherche de commande. Remplacez par un appel réseau réel. rng = random.Random(hash(order_id) & 0xFFFFFFFF) status = rng.choice(["processing", "fulfilled", "cancelled"]) items: List[Dict[str, Any]] = [ {"sku": "SKU-001", "name": "Widget A", "qty": 2, "unit_price": 19.99}, {"sku": "SKU-045", "name": "Gadget B", "qty": 1, "unit_price": 49.9}, ] total = sum(i["qty"] * i["unit_price"] for i in items) return { "id": order_id, "status": status, "currency": "USD", "total": round(total, 2), "items": items, "customer": { "id": "CUST-1827", "name": "Jane Doe", "email": "jane.doe@example.com", }, "created_at": datetime.datetime.utcnow().isoformat() + "Z", "source": "CometAPI", } ``` direct_lookup.py ```python # direct_lookup.py # Exécute la recherche de commande directement via CometAPI (sans MCP). import os import json from comet_api import CometAPI def lookup_order_direct(order_id: str) -> dict: api_key = os.environ.get("COMET_API_KEY", "dev-key") api = CometAPI(api_key=api_key) return api.get_order(order_id) if __name__ == "__main__": order_id = os.environ.get("ORDER_ID", "ORDER-12345") result = lookup_order_direct(order_id) print(json.dumps(result, indent=2, ensure_ascii=False)) ``` mcp_server.py ```python # mcp_server.py # Serveur MCP qui expose l’outil "lookup_order" via CometAPI. # Nécessite la bibliothèque Python MCP. Adaptez l’import selon votre environnement MCP. import os import json import asyncio from typing import Any, Dict # Bibliothèques MCP (les noms peuvent varier selon la version) try: from mcp.server import Server from mcp.server.stdio import stdio_server from mcp.types import TextContent except ImportError: raise ImportError("La bibliothèque MCP Python est requise (par ex. 'mcp').") from comet_api import CometAPI server = Server("comet-mcp-server") # Définition de l’outil avec schéma d’entrée JSON @server.tool( name="lookup_order", description="Recherche une commande par identifiant dans CometAPI.", input_schema={ "type": "object", "properties": {"order_id": {"type": "string"}}, "required": ["order_id"], }, ) async def lookup_order(params: Dict[str, Any]) -> list[TextContent]: order_id = params["order_id"] api_key = os.environ.get("COMET_API_KEY", "dev-key") api = CometAPI(api_key=api_key) data = api.get_order(order_id) # Retourne le contenu texte (MCP supporte contenus structurés; ici, JSON sérialisé) return [TextContent(type="text", text=json.dumps(data))] async def main(): # Démarre le serveur MCP sur stdio async with stdio_server() as (read, write): await server.run(read, write) if __name__ == "__main__": asyncio.run(main()) ``` mcp_client.py ```python # mcp_client.py # Client MCP qui lance le serveur en sous-processus et appelle l’outil "lookup_order". import os import json import asyncio try: from mcp.client import Client from mcp.client.stdio import stdio_client except ImportError: raise ImportError("La bibliothèque MCP Python est requise (par ex. 'mcp').") async def run_via_mcp(order_id: str): # Lance le serveur MCP local (mcp_server.py) via stdio et appelle l’outil async with stdio_client(command=["python", "mcp_server.py"]) as (read, write): client = Client(read, write) await client.initialize() # négociation de capacités # Liste les outils disponibles (facultatif) tools = await client.list_tools() # Appel de l’outil avec paramètres result = await client.call_tool("lookup_order", {"order_id": order_id}) # Agrège le texte des contenus retournés texts = [] for content in result.contents: if getattr(content, "type", None) == "text": texts.append(content.text) return "\n".join(texts) if __name__ == "__main__": order_id = os.environ.get("ORDER_ID", "ORDER-12345") output = asyncio.run(run_via_mcp(order_id)) # Le serveur renvoie du JSON sérialisé en texte parsed = json.loads(output) print(json.dumps(parsed, indent=2, ensure_ascii=False)) ``` Notes d’exécution (même recherche de commande, deux chemins) - Exécution directe: - python direct_lookup.py - Exécution via MCP: - python mcp_client.py Structure des résultats - Les deux chemins renvoient un objet JSON avec: - id, status, currency, total, items (sku, name, qty, unit_price), customer (id, name, email), created_at, source - Le parcours “direct” appelle CometAPI directement. - Le parcours “MCP” appelle l’outil standardisé “lookup_order” servi par mcp_server.py via un client MCP, ce qui permet la découverte d’outil, la validation de schéma et le découplage du runtime.