CometAPI fournit une passerelle unique, compatible OpenAI, vers de nombreux modèles (famille GPT, Anthropic/Claude, Google Gemini, etc.). LlamaIndex (le « framework de données » pour la création d'applications LLM avec récupération augmentée) propose désormais une intégration LLM CometAPI native, ce qui signifie que vous pouvez appeler n'importe quel modèle via CometAPI depuis LlamaIndex.
LlamaIndex (le cadre de données pour la création d'assistants de connaissances) prend désormais officiellement en charge API Comet en tant que backend LLM. Ce guide explique pourquoi les associer, comment configurer l'environnement, l'intégration étape par étape (avec code), un cas d'utilisation concret de RAG et des conseils pour améliorer la fiabilité, les coûts et l'observabilité. Des exemples suivent. Documentation de LlamaIndex et la Exemples d'intégration CometAPI.
Qu'est-ce que LlamaIndex et quelles sont ses principales fonctionnalités ?
LlamaIndex (anciennement GPT-Index) est un framework d'abstraction et de récupération de données qui connecte les grands modèles de langage (LLM) à vos propres données en ingérant des documents, en créant des index et en orchestrant des workflows de récupération et d'invite pour les applications de type RAG. Ses principales fonctionnalités incluent des connecteurs d'ingestion de documents (PDF, web, bases de données), des index vectoriels/mots-clés/graphiques, des moteurs de requête flexibles et une couche d'abstraction pour le changement de fournisseur LLM. LlamaIndex est conçu pour vous permettre d'intégrer vos propres données à n'importe quel LLM et crée les bases nécessaires à la segmentation, à l'incorporation, à la récupération et à l'orchestration des invites de documents.
Quelles sont les principales fonctionnalités ?
- Connecteurs de données: ingérer à partir de fichiers, de bases de données et de nombreuses sources SaaS.
- Primitives d'indexation: index de stockage vectoriel, index d'arbre/graphique et pipelines de récupération.
- Moteurs de requête: orchestration flexible des requêtes (rerankers, synthèse des réponses, invites en plusieurs étapes).
- Adaptateurs LLM: backends LLM enfichables — OpenAI, Anthropic, Vertex et maintenant CometAPI entre autres.
- Observabilité et rappels: hooks pour tracer et surveiller les appels LLM.
Qu'est-ce que CometAPI et pourquoi l'utiliser avec LlamaIndex ?
Qu'est-ce que CometAPI ?
CometAPI est une passerelle API qui expose des centaines de modèles d'IA tiers (LLM, générateurs d'images/vidéos et intégrations) via une interface REST unique et compatible OpenAI. Au lieu de jongler avec un SDK et une clé distincts pour chaque fournisseur de modèle, il suffit d'appeler l'URL de base de CometAPI et de sélectionner le nom du modèle dans le corps de la requête, par exemple. gpt, claude, gemini, ou divers moteurs d'intégration/d'images spécialisés. Cette approche « une API pour plus de 500 modèles » accélère l'expérimentation et réduit les frais opérationnels.
Pourquoi associer CometAPI à LlamaIndex ?
LlamaIndex est un framework de données qui transforme vos documents en index (vecteurs et autres) et utilise un LLM pour la synthèse des réponses finales. Comme CometAPI utilise une API de type OpenAI, LlamaIndex peut :
- Utilisez son intégré
CometAPIIntégration LLM (recommandé), ou - Utilisez les adaptateurs LLM et d'intégration OpenAI/« compatible OpenAI » en pointant
api_baseà CometAPI.
LlamaIndex fournit déjà un CometAPI Wrapper et exemples LLM — l'intégration est donc intentionnellement simple.
Quels sont les avantages de l’intégration ?
- RAG + choix de modèle flexible — LlamaIndex gère la récupération des données et la synthèse rapide ; CometAPI vous permet de choisir le(s) LLM que vous appelez sans réorganiser votre pipeline.
- Optimisation coût/latence — essayez des modèles moins chers ou plus rapides pour les requêtes de routine et des modèles de meilleure qualité pour le raisonnement lourd.
- Portabilité des fournisseurs — échanger les fournisseurs de modèles en changeant uniquement les noms de modèles ou une petite configuration client.
- Expérimentation rapide — créez facilement des modèles A/B tout en gardant votre pipeline d'indexation et de récupération constant.
Quelles sont les conditions préalables et la configuration de l'environnement ?
Comptes et clés
Inscrivez-vous à CometAPI et obtenez une clé API depuis la console CometAPI : https://api.cometapi.com/console/token. (Vous aurez besoin de cette valeur pour authentifier les demandes.)
Python et packages
- Python 3.9+ recommandé.
- Environnement Jupyter Notebook ou Python (Google Colab recommandé pour les tests interactifs).
- Paquets à installer :
llama-index(noyau) etllama-index-llms-cometapi(l'adaptateur / intégration CometAPI) - Facultatif : les bibliothèques de stockage de vecteurs que vous prévoyez d'utiliser (par exemple,
faiss-cpu,pinecone-client, etc.). LlamaIndex dispose de guides de magasin officiels/vectoriels.
Variables d'environnement
Pratique courante : définir la clé CometAPI comme une variable d'environnement (par exemple COMETAPI_KEY), ou transmettez la clé directement au constructeur CometAPI de LlamaIndex. La documentation de LlamaIndex présente les deux approches : pour éviter toute ambiguïté et éviter les tests, transmettez api_key= explicitement au constructeur est le plus sûr.
Comment intégrer LlamaIndex et CometAPI étape par étape ?
La liste étape par étape suivante couvre les actions exactes : créer un compte, installer des packages, définir des clés, configurer LlamaIndex pour utiliser CometAPI.
1) Comment créer un compte CometAPI et obtenir une clé API ?
- Visitez le site de CometAPI et créez un compte. (Leur page d'accueil et le processus d'inscription vous redirigeront vers la console API.)
- Dans la console CometAPI (la référence de la documentation
https://api.cometapi.com/console/token), créez ou copiez votre jeton d'API. Vous en aurez besoin pourCOMETAPI_API_KEY(voir ci-dessous).
2) Comment installer LlamaIndex et l'intégration CometAPI ?
Exécutez ces commandes pip (recommandées dans un environnement virtuel) :
# core LlamaIndex
pip install llama-index
# CometAPI LLM integration for LlamaIndex
pip install llama-index-llms-cometapi
# optional: vectorstore (FAISS example)
pip install faiss-cpu
(If you're in a Jupyter/Colab environment you can prefix with `%pip`.)
Remarques :
- LlamaIndex utilise des packages d'intégration avec espace de noms pour éviter de tout intégrer au cœur. L'intégration CometAPI LLM est fournie sous la forme
llama-index-llms-cometapi.
3) Comment définir la clé CometAPI (variable d'environnement) ?
La classe LLM CometAPI de LlamaIndex lit la clé API depuis un paramètre de constructeur ou une variable d'environnement. Le code d'intégration attend le nom de la variable d'environnement. COMETAPI_API_KEY (vous pouvez également transmettre la clé directement au constructeur de la classe). Il prend également en charge COMETAPI_API_BASE si vous devez remplacer l'URL de base de l'API.
Recommandé (explicite) — transmettre la clé API au constructeur. Vous pouvez également définir la variable d'environnement COMETAPI_KEY si vous préférez.
import os
# Option A: set env var (optional)
os.environ = "sk-xxxx-your-key"
# Option B: pass the key explicitly (recommended for clarity)
api_key = os.getenv("COMETAPI_KEY", "sk-xxxx-your-key")
Définissez-le localement (Unix/macOS) :
export COMETAPI_API_KEY="sk-<your-cometapi-key>"
# optional override:
export COMETAPI_API_BASE="https://www.cometapi.com/console/"
Sous Windows (PowerShell) :
$env:COMETAPI_API_KEY = "sk-<your-cometapi-key>"
4) Configurer LlamaIndex pour utiliser CometAPI
Voici un exemple minimal de bout en bout : ingérez des documents, créez un index vectoriel et exécutez une requête. Cet exemple utilise l'API LlamaIndex moderne (exemple A : ServiceContext + index vectoriel). Adaptez les noms si vous utilisez une version plus ancienne/plus récente de LlamaIndex.
minimal RAG example using CometAPI as the LLM backend
from llama_index import SimpleDirectoryReader, VectorStoreIndex, ServiceContext
from llama_index.llms.cometapi import CometAPI
from llama_index.core.llms import ChatMessage
# 1) API key and LLM client
api_key = "sk-xxxx-your-key" # or read from env
llm = CometAPI(
api_key=api_key,
model="gpt-4o-mini", # pick a CometAPI-supported model
max_tokens=512,
context_window=4096,
)
# 2) Optional: wrap in ServiceContext (customize prompt settings, embedding model etc)
service_context = ServiceContext.from_defaults(llm=llm)
# 3) Load documents (assumes a ./data directory with files)
documents = SimpleDirectoryReader("data").load_data()
# 4) Build a vector index (FAISS, default vector store)
index = VectorStoreIndex.from_documents(documents, service_context=service_context)
# 5) Query the index
query_engine = index.as_query_engine()
resp = query_engine.query("Summarize the main points in the documents.")
print(resp)
- Les noms de modèles et les fonctionnalités disponibles dépendent de CometAPI. Consultez la documentation de CometAPI pour choisir le modèle le plus adapté à votre cas d'utilisation. L'adaptateur Comet LlamaIndex prend en charge les modes chat, complétion et streaming.
- Si vous souhaitez des réponses en streaming, vous pouvez appeler
llm.stream_chat()ou utiliser lestream_completevariante montrée dans les docs.
Remarque : selon votre version de LlamaIndex, l'API exacte pour
as_query_engineaccepter unllmL'argumentation peut varier. Si votre version n'accepte paslServiceContextVoir le LLM ci-dessous. Le LLM CometAPI est implémenté comme suit :CometAPIinllama_index.llms.cometapi.
Exemple B — Utilisation minimale et directe de CometAPI LLM (recommandé pour plus de clarté)
import os
from llama_index.llms.cometapi import CometAPI
from llama_index import VectorStoreIndex, SimpleDirectoryReader
# ensure env var set, or pass api_key explicitly
os.environ = "sk-<your-key>" # or set externally
api_key = os.getenv("COMETAPI_API_KEY")
llm = CometAPI(
api_key=api_key, # or pass None to use env var
model="gpt-4o-mini", # change model string as required
max_tokens=256,
context_window=4096,
)
# build a simple index (local documents)
documents = SimpleDirectoryReader("data/").load_data()
index = VectorStoreIndex.from_documents(documents)
# get a query engine that uses the default llm (you can often pass llm to the query method)
query_engine = index.as_query_engine(llm=llm) # some LlamaIndex versions accept llm here
response = query_engine.query("Summarize the key points of the corpus.")
print(response)
Comment puis-je utiliser les fonctionnalités CometAPI de LlamaIndex ? (exemples avancés)
1) Appeler chat avec la liste ChatMessage
Exemple :
# Initialize LLM
llm = CometLLM(
api_key=api_key,
max_tokens=256,
context_window=4096,
model="gpt-5-chat-latest",
)
# Chat call using ChatMessage
from llama_index.core.llms import ChatMessage
messages = [
ChatMessage(role="system", content="You are a helpful assistant"),
ChatMessage(role="user", content="Say 'Hi' only!"),
]
resp = llm.chat(messages)
print(resp)
# Use complete method
resp = llm.complete("Who is Kaiming He")
print(resp)
Production attendue:
- Réponse au chat : par exemple,
assistant: Hi - Réponse de complétion : par exemple, une description textuelle sur Kaiming He, y compris des informations sur ResNet.
Cela reproduit la sémantique du chat (rôles système/utilisateur/assistant) et produit souvent des résultats plus contrôlables. Cela envoie un message simple et récupère la réponse du modèle. Vous pouvez personnaliser les messages pour des interactions plus complexes.
CometAPI prend-il en charge le streaming ?
Oui — CometAPI prend en charge le streaming de chat/complétions et LlamaIndex expose les méthodes de streaming sur ses wrappers LLM (stream_chat, stream_complete, streamable (modèles). Pour les applications en temps réel, utilisez les méthodes stream_chat ou stream_complete pour diffuser les réponses. Exemple :
# Streaming chat
message = ChatMessage(role="user", content="Tell me what ResNet is")
resp = llm.stream_chat()
for r in resp:
print(r.delta, end="")
# Streaming completion
resp = llm.stream_complete("Tell me about Large Language Models")
for r in resp:
print(r.delta, end="")
Production attendue: Diffusion en continu du contenu de réponse imprimé, par exemple une explication de ResNet ou un aperçu de grands modèles linguistiques, apparaissant par morceaux.
Explication: stream_chat et stream_complete génèrent des réponses fragment par fragment, adaptées à une sortie en temps réel. Toute erreur est signalée dans la console.
Ceci reflète les exemples LlamaIndex d'autres LLM compatibles OpenAI et fonctionne avec les points de terminaison de streaming de Comet. Gérez la contre-pression et les erreurs réseau grâce à une logique robuste de nouvelle tentative/délai d'expiration en production.
Changer de modèle rapidement
# try Claude from CometAPI
claude_llm = CometAPI(api_key=api_key, model="claude-3-7-sonnet-latest", max_tokens=300)
svc = ServiceContext.from_defaults(llm=claude_llm)
index = VectorStoreIndex.from_documents(documents, service_context=svc)
print(index.as_query_engine().query("Explain in one paragraph."))
Étant donné que CometAPI normalise les points de terminaison, la modification des modèles est uniquement une modification du constructeur : aucune réécriture rapide du pipeline n'est requise.
Conseils et techniques d'amélioration
Comment gérer les coûts et les jetons
- Utiliser la récupération : envoyer uniquement le contexte récupéré, pas l'ensemble du corpus.
- Expérimentez avec des modèles plus petits pour la récupération/résumé et des modèles plus grands pour la synthèse des réponses finales. CometAPI simplifie les échanges de modèles.
Fiabilité et limitation de débit
- Mettre en œuvre le réessayer + reculer pour les erreurs transitoires.
- Respectez les limites de débit de CometAPI et implémentez un budget de jetons par requête. Suivi
max_tokensdans le constructeur.
Observabilité et débogage
- Utilisez le gestionnaire de rappels LlamaIndex pour capturer les invites, les réponses et l'utilisation des jetons. Intégrez ces journaux à votre pipeline de surveillance. La documentation de LlamaIndex couvre les modèles d'observabilité et les intégrations.
Mise en cache et latence
- Mettez en cache les sorties LLM pour les requêtes répétées ou les invites déterministes (par exemple, les résumés standard).
- Envisagez d’utiliser un modèle plus petit et plus rapide pour le premier passage et de passer à un modèle plus coûteux uniquement lorsque cela est nécessaire.
Sécurité
- Conservez la clé CometAPI dans un magasin de secrets (Vault / secrets cloud) — ne la codez pas en dur dans le code.
- Si les données sont sensibles, assurez-vous que le plan ou le modèle CometAPI que vous avez choisi répond aux exigences de conformité.
Liste de contrôle de dépannage
- Variable d'environnement incorrecte: Si LlamaIndex ne trouve pas de clé, passez
api_key=dans leCometAPI()Le constructeur doit être explicite. (La documentation présente les options de la variable d'environnement et du constructeur.) - Modèle non pris en charge:Confirmez le nom du modèle avec la liste des modèles de CometAPI — tous les noms n'existent pas sur tous les comptes.
- Erreurs d'indexation: Assurez-vous que les documents sont correctement analysés (encodage, types de fichiers). Utilisation
SimpleDirectoryReaderpour une ingestion test rapide. - Dérive de versionLlamaIndex évolue activement (migration ServiceContext → Paramètres). Si un exemple échoue, consultez la documentation et le guide de migration de la version installée.
Pour commencer
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 dans le cour de récréation et consultez le LamaIndex Pour des instructions détaillées, veuillez vous connecter à CometAPI et obtenir la clé API avant d'y accéder. API Comet 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 !
FAQ
Comment déboguer les interruptions de latence ou de streaming ?
- Utilisez une capture de réseau local (ou connectez-vous à votre client HTTP) pour inspecter les trames en streaming.
- Essayez un modèle plus simple pour confirmer que le chemin réseau/SDK, et non le modèle lui-même, constitue le goulot d’étranglement.
Quel modèle dois-je choisir ?
- Utilisez des modèles de chat plus petits/moins chers (par exemple,
gpt-4o-mini,o4-mini, ou des modèles compacts spécifiques au fournisseur) pour des QPS élevés ou des réponses courtes. - Réservez les grands modèles multimodaux / de chaîne de pensée aux tâches de raisonnement coûteuses.
- Latence et coût de référence : l’un des avantages de CometAPI est de changer de modèle dans le même chemin de code : essayez rapidement plusieurs modèles.
Quel index et quel magasin de vecteurs dois-je choisir ?
- FAISS pour une vitesse sur site / à nœud unique.
- Pomme de pin / Weaviate Pour une évolutivité gérée et une disponibilité multirégionale (LlamaIndex prend en charge de nombreux magasins vectoriels grâce à des intégrations). Choisissez en fonction de l'évolutivité et de la latence.