Guide d'intégration de Gate.AI LangChain et LangGraph

Gate.AI fournit un point de terminaison API compatible avec OpenAI, permettant aux développeurs de combiner LangChain et LangGraph pour effectuer des appels de modèles via le routage Gate.AI. Lorsqu'une application Python doit utiliser des invites basées sur des chaînes, des agents basés sur des graphes, ou souhaite construire une passerelle de modèles unifiée sans réécrire la logique pour chaque fournisseur de modèles, cette solution est particulièrement importante. Cet article présente la configuration en environnement local, les tests d'appel avec LangChain, la création de chaînes d'invite LangChain, ainsi qu'un flux de travail simple avec LangGraph. Il ne couvre pas le déploiement en production, les bases de données vectorielles, la observabilité, la facturation ou les stratégies d'accès d'entreprise.

Prérequis

• Avoir créé une clé API Gate.AI via un compte Gate.AI
• Python 3.10 ou supérieur, avec droits d'installation de dépendances

Source : Documentation officielle et matériel produit de Gate.AI, à jour jusqu’en juin 2026.

Quelles capacités obtiendrez-vous après avoir suivi ce guide ?

Vous pourrez connecter Gate.AI à LangChain via ChatOpenAI, et réutiliser la même configuration de modèle dans un flux de travail LangGraph.

Ce plan vous aidera à :

• Appeler Gate.AI depuis un script Python local
• Tester la configuration model="auto" avec le routage Gate.AI
• Remplacer auto par un ID de modèle Gate.AI vérifié si nécessaire
• Exécuter une chaîne d'invite LangChain
• Réaliser un flux de travail LangGraph en deux étapes

Pour une vue d’ensemble plus large de l’intégration API, consultez la documentation d’intégration API pour développeurs Gate.AI.

Étape 1 : Installer les dépendances Python

Cette étape installe les intégrations nécessaires pour LangChain OpenAI et LangGraph.

• Créer et activer un environnement virtuel :

  bash python -m venv .venv source .venv/bin/activate

  pip install -U langchain langchain-openai langgraph

• Commande pour l’activer sous PowerShell Windows :

  powershell .venv\Scripts\Activate.ps1

Une fois installé, vous devriez pouvoir importer normalement langchain_openai et langgraph.

Étape 2 : Stocker la clé API Gate.AI

Cette étape consiste à sauvegarder la clé API en dehors du code source.

• En environnement bash, définir une variable d’environnement :

  bash export GATEAI_API_KEY="VOTRE_CLÉ_API"

• En PowerShell Windows :

  powershell setx GATEAI_API_KEY "VOTRE_CLÉ_API"

Après setx, il faut redémarrer la session PowerShell pour que la variable soit prise en compte.

Ne soumettez pas votre vraie clé API sur Git. Pour un projet d’équipe, utilisez un gestionnaire de clés, une configuration CI/CD, ou un processus interne approuvé pour la gestion des variables.

Étape 3 : Configurer Gate.AI dans LangChain

Cette étape consiste à créer un modèle de chat dans LangChain qui envoie des requêtes compatibles OpenAI à Gate.AI.

• Selon la documentation Gate.AI de juin 2026, l’URL de base compatible OpenAI est :

• Dans LangChain, utilisez cette URL comme base_url. Il n’est pas nécessaire d’ajouter /chat/completions, LangChain le gère automatiquement.

• Exemple :

  python import os from langchain_openai import ChatOpenAI

  llm = ChatOpenAI( model="auto", api_key=os.environ["GATEAI_API_KEY"], base_url="", temperature=0, )

  response = llm.invoke("Écrivez une phrase expliquant ce que fait un routeur de modèles AI.") print(response.content)

Sortie attendue :

Le routeur de modèles AI distribue la requête au modèle approprié selon la tâche, les règles de routage ou la configuration.

Le contenu réel peut varier, car le routage Gate.AI répond dynamiquement en fonction du modèle sélectionné.

Étape 4 : Construire une chaîne d’invite LangChain

Cette étape connecte une invite réutilisable, le modèle supporté par Gate.AI, et un parseur de sortie en chaîne.

• Exemple :

  python import os from langchain_openai import ChatOpenAI from langchain_core.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser

  llm = ChatOpenAI( model="auto", api_key=os.environ["GATEAI_API_KEY"], base_url="", temperature=0, )

  prompt = ChatPromptTemplate.from_messages( [ ("system", "Vous êtes un assistant technique concis."), ("human", "Expliquez {topic} en trois points."), ] )

  chain = prompt | llm | StrOutputParser()

  result = chain.invoke({"topic": "Routage API Gate.AI"}) print(result)

Vous verrez une explication claire en trois points. Si le script renvoie une erreur avant le texte, vérifiez d’abord la clé API, le base_url et la configuration du modèle, plutôt que de modifier directement la chaîne.

Étape 5 : Configurer Gate.AI dans LangGraph

Cette étape consiste à réutiliser la même configuration de modèle Gate.AI dans un flux de travail LangGraph.

L’exemple ci-dessous crée un nœud pour générer une brève description, puis un autre pour la révision, pour garder le flux simple et vérifier la fonctionnalité de base avant d’ajouter outils, mémoire, recherche ou routage conditionnel.

• Exemple :

  python import os from typing_extensions import TypedDict from langchain_openai import ChatOpenAI from langgraph.graph import StateGraph, START, END

  llm = ChatOpenAI( model="auto", api_key=os.environ["GATEAI_API_KEY"], base_url="", temperature=0, )

  class WorkflowState(TypedDict): topic: str draft: str review: str

  def draft_node(state: WorkflowState) -> dict: response = llm.invoke( [ ("system", "Vous écrivez des explications techniques courtes."), ("human", f"Rédigez une explication en deux phrases de {state['topic']}."), ] ) return {"draft": response.content}

  def review_node(state: WorkflowState) -> dict: response = llm.invoke( [ ("system", "Vous relisez un texte technique pour la clarté."), ("human", f"Révisez ce brouillon et suggérez une amélioration :\n\n{state['draft']}"), ] ) return {"review": response.content}

  builder = StateGraph(WorkflowState) builder.add_node("draft", draft_node) builder.add_node("review", review_node)

  builder.add_edge(START, "draft") builder.add_edge("draft", "review") builder.add_edge("review", END)

  app = builder.compile()

  result = app.invoke({"topic": "Gate.AI avec LangGraph"})

  print("Brouillon:\n", result["draft"]) print("\nRevue:\n", result["review"])

Vous verrez le brouillon généré et la revue. Si le flux ne retourne que le brouillon, vérifiez que l’arête de draft à review est bien configurée.

Étape 6 : Remplacer le routage automatique par un modèle spécifique

Pour un contrôle accru, vous pouvez fixer le modèle comme suit :

• Si le routage automatique Gate.AI est activé et que votre compte le supporte, utilisez initialement model="auto"

• Pour une reproductibilité, une évaluation cohérente, ou une validation en production, utilisez l’ID de modèle spécifique de Gate.AI

• Exemple :

  python llm = ChatOpenAI( model="VOTRE_ID_MODELE", api_key=os.environ["GATEAI_API_KEY"], base_url="", temperature=0, )

L’ID de modèle s’obtient dans le catalogue de modèles Gate.AI ou via la console Gate.AI. Ne devinez pas l’ID, car la disponibilité dépend du compte, du produit, et des règles du fournisseur (à juin 2026).

Quelles options de configuration sont cruciales ?

| Option de configuration | Exemple | Cas d’usage | Commentaire important | |--------------------------|---------|--------------|------------------------| | Variable de clé API | GATEAI_API_KEY | Shell et code Python | Garantit que le secret ne figure pas dans le code source | | Base URL | | ChatOpenAI(base_url=...) | Route les requêtes compatibles OpenAI vers Gate.AI | | Modèle | auto ou VOTRE_ID_MODELE | ChatOpenAI(model=...) | Choix entre routage automatique ou modèle spécifique | | Température | 0 | ChatOpenAI(temperature=0) | Réduit la variabilité en test |

Pour maintenir la cohérence du routage, utilisez le même objet llm dans LangChain et LangGraph. Modifiez le paramètre model uniquement si vous passez d’un routage automatique à un modèle fixe.

Dépannage courant de l’intégration Gate.AI LangChain et LangGraph

Problème : réponse 401, invalid_api_key ou erreur d’authentification

• Cause : Clé API manquante, expirée, mal orthographiée ou non accessible dans le shell courant
• Solution : Vérifier avec echo $GATEAI_API_KEY dans le même terminal. La clé doit être valide et configurée dans Gate.AI. Si vous avez défini la variable dans une autre session, redémarrez le terminal.

Problème : réponse 404, échec de connexion ou endpoint introuvable

• Cause : Mauvaise configuration du base_url. L’URL compatible OpenAI doit être :
• Solution : Vérifier que chaque instance de ChatOpenAI a base_url correctement configuré.

Problème : ModuleNotFoundError en Python

• Cause : La virtualenv n’a pas installé langchain-openai ou langgraph
• Solution : Après activation, exécuter : pip install -U langchain langchain-openai langgraph

Problème : Authentification réussie mais erreur lors de la requête modèle

• Cause : Le modèle choisi n’est pas disponible, mal orthographié, ou non supporté par la requête
• Solution : Tester avec model="auto". Pour un modèle fixe, copier l’ID valide depuis Gate.AI.

Problème : Flux LangGraph incomplet ou ne retournant pas tous les états attendus

• Cause : Un nœud ne retourne pas la clé d’état attendue, ou la structure du graphe est incomplète
• Solution : Vérifier que chaque nœud retourne un dictionnaire avec la clé correcte, et que le graphe inclut START, les arêtes entre nœuds, et END.

Quelles autres configurations ou développements possibles ?

• Intégration via API développeur Gate.AI pour étendre le workflow local à l’ensemble de l’écosystème Gate.AI
• Pour une intégration dans un éditeur de code IA, voir le guide d’intégration Gate.AI Cursor
• Pour des workflows impliquant Claude Code ou des configurations compatibles avec Anthropic, voir le guide d’intégration Gate.AI Claude Code

FAQ

LangChain et LangGraph peuvent-ils partager la même configuration Gate.AI ?
Oui. Créez un objet ChatOpenAI avec la clé API, le base_url, et le modèle choisi, puis réutilisez-le dans la chaîne ou le nœud.

Faut-il utiliser auto ou un ID de modèle spécifique ?
Si le routage automatique Gate.AI est activé, commencez par auto. Pour la reproductibilité ou la production, utilisez un ID précis.

Pourquoi le base_url doit-il contenir /openai/v1 ?
Gate.AI utilise cette route pour la compatibilité OpenAI. ChatOpenAI doit pointer vers cette URL, pas une version raccourcie.

Faut-il modifier LangGraph pour cette intégration ?
Non. La configuration Gate.AI est entièrement dans l’objet ChatOpenAI utilisé dans les nœuds. LangGraph ne nécessite pas de modification.