Guía de integración de Gate.AI LangChain y LangGraph

Gate.AI ofrece puntos finales API compatibles con OpenAI, que los desarrolladores pueden usar para combinar LangChain y LangGraph, logrando llamadas a modelos mediante enrutamiento a través de Gate.AI. Cuando una aplicación en Python necesita prompts basados en cadenas, flujos de trabajo de agentes basados en gráficos, o desea construir una puerta de enlace de modelos unificada que no requiera reescribir lógica para cada proveedor de modelos, esta solución es especialmente importante. Este documento cubrirá la configuración en entorno local, pruebas de llamadas con LangChain, cadenas de prompts en LangChain y un flujo de trabajo simple en LangGraph. No se abordarán despliegues en producción, bases de datos vectoriales, observabilidad, facturación o políticas de acceso empresarial.

Requisitos previos

• Haber creado una clave API de Gate.AI mediante una cuenta de Gate.AI
• Tener Python 3.10 o superior, y permisos para instalar paquetes dependientes

Fuente del contenido: Documentación oficial y materiales de producto de Gate.AI, con fecha hasta junio de 2026.

¿Qué capacidades obtendrás tras completar esta guía?

Podrás integrar Gate.AI en LangChain usando ChatOpenAI y reutilizar la misma configuración de modelo en flujos de trabajo de LangGraph.

Este enfoque te ayudará a:

• Llamar a Gate.AI desde scripts Python locales
• Probar la configuración de enrutamiento de modelos con model="auto" en Gate.AI
• Cuando sea necesario, reemplazar auto por el ID de modelo verificado de Gate.AI
• Ejecutar cadenas de prompts en LangChain
• Ejecutar flujos de trabajo de dos pasos en LangGraph

Para una visión más amplia sobre integración API, consulta la documentación de API para desarrolladores de Gate.AI.

Paso 1: Instalar dependencias de Python

Este paso instalará los paquetes necesarios para el flujo de trabajo local: integración de LangChain con OpenAI y LangGraph.

• Crear y activar un entorno virtual:

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

  pip install -U langchain langchain-openai langgraph

• Comando para activar en PowerShell en Windows:

  powershell .venv\Scripts\Activate.ps1

Tras la instalación, deberías poder importar correctamente langchain_openai y langgraph.

Paso 2: Guardar la clave API de Gate.AI

Este paso guarda la clave API fuera del código fuente.

• En entorno bash, configurar variable de entorno:

  bash export GATEAI_API_KEY="TU_CLAVE_API"

• En PowerShell en Windows:

  powershell setx GATEAI_API_KEY "TU_CLAVE_API"

Tras usar setx, reinicia la sesión de PowerShell para que los cambios tengan efecto.

No compartas tu clave API real en Git. Para proyectos en equipo, usa gestores de secretos, configuración de claves en CI, o variables de entorno internas aprobadas.

Paso 3: Configurar Gate.AI en LangChain

Este paso crea un modelo de chat en LangChain que envía solicitudes compatibles con OpenAI a Gate.AI.

• Según la documentación de Gate.AI de junio de 2026, la URL base compatible con OpenAI es:

• En LangChain, usa esa URL como base_url. No añadas /chat/completions; LangChain gestionará la ruta automáticamente.

• Ejemplo:

  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("Escribe una oración explicando qué hace un enrutador de modelos de IA.") print(response.content)

Salida esperada:

El enrutador de modelos de IA enrutará las solicitudes al modelo adecuado según la tarea, reglas de enrutamiento o configuración.

El contenido real puede variar, ya que Gate.AI enrutará dinámicamente según el modelo seleccionado.

Paso 4: Construir una cadena de prompts en LangChain

Este paso conecta prompts reutilizables, modelos soportados por Gate.AI y un parser de salida de cadenas.

• Ejemplo:

  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", "Eres un asistente técnico conciso."), ("human", "Explica {topic} en tres puntos clave."), ] )

  chain = prompt | llm | StrOutputParser()

  resultado = chain.invoke({"topic": "Enrutamiento de API de Gate.AI"}) print(resultado)

Verás una explicación breve en tres puntos. Si el script da error antes de devolver texto, revisa primero la clave API, base_url y configuración del modelo, no modifiques directamente la estructura de la cadena.

Paso 5: Configurar Gate.AI en LangGraph

Este paso reutiliza la misma configuración de modelo de Gate.AI en un flujo de trabajo en LangGraph.

El ejemplo genera una breve descripción en un nodo, y otro nodo realiza una revisión, manteniendo el flujo simple para validar funciones básicas antes de agregar herramientas, memoria, recuperación o enrutamiento condicional.

• Ejemplo:

  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 EstadoFlujo(TypedDict): topic: str borrador: str revisión: str

  def nodo_borrador(estado: EstadoFlujo) -> dict: respuesta = llm.invoke( [ ("system", "Escribes explicaciones técnicas cortas."), ("human", f"Escribe una explicación de dos oraciones sobre {estado['topic']}."), ] ) return {"borrador": respuesta.content}

  def nodo_revisión(estado: EstadoFlujo) -> dict: respuesta = llm.invoke( [ ("system", "Revisas la escritura técnica para claridad."), ("human", f"Revisa este borrador y sugiere una mejora:\n\n{estado['borrador']}"), ] ) return {"revisión": respuesta.content}

  builder = StateGraph(EstadoFlujo) builder.add_node("borrador", nodo_borrador) builder.add_node("revisión", nodo_revisión)

  builder.add_edge(START, "borrador") builder.add_edge("borrador", "revisión") builder.add_edge("revisión", END)

  app = builder.compile()

  resultado = app.invoke({"topic": "Gate.AI con LangGraph"})

  print("Borrador:\n", resultado["borrador"]) print("\nRevisión:\n", resultado["revisión"])

Verás el borrador generado y la revisión. Si solo quieres el borrador, asegúrate de que la arista de borrador a revisión esté correctamente configurada.

Paso 6: Reemplazar enrutamiento automático por un modelo específico

Para mayor control, puedes fijar un modelo concreto en lugar de usar auto:

• Si Gate.AI enrutamiento automático está habilitado y tu cuenta lo soporta, prueba inicialmente con model="auto"

• Para resultados reproducibles, evaluación consistente, pruebas de latencia o revisión en producción, usa el ID de modelo específico de Gate.AI

• Ejemplo:

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

Obtén el ID de modelo desde el catálogo de modelos de Gate.AI o desde la consola. No adivines IDs, ya que la disponibilidad depende de tu cuenta, estado del producto y reglas del proveedor (a junio de 2026).

¿Qué configuraciones son las más importantes?

| Opción de configuración | Valor de ejemplo | Uso típico | Comentario importante | | ------------------------- | -------------------------------------------------- | ------------------------------ | --------------------------------------------------- | | Variable de clave API | GATEAI_API_KEY | Shell y código Python | Mantiene las credenciales fuera del código fuente | | Base URL | (vacío o la URL proporcionada) | ChatOpenAI(base_url=...) | Enrutamiento a Gate.AI para solicitudes compatibles con OpenAI | | Modelo | auto o TU_ID_DE_MODELO | ChatOpenAI(model=...) | Enrutamiento automático o modelo específico | | Temperatura | 0 | ChatOpenAI(temperature=0) | Para entornos de prueba, reducir variabilidad |

Para mantener el enrutamiento consistente, usa el mismo objeto llm en LangChain y LangGraph. Solo cambia el modelo a un valor fijo si pasas de pruebas de enrutamiento a pruebas con modelo fijo.

Solución de problemas comunes en integración LangChain y LangGraph con Gate.AI

Problema: Respuesta con 401, invalid_api_key o error de autenticación

• Causa: Clave API ausente, caducada, mal escrita o shell no la lee
• Solución: Ejecuta en la misma terminal: echo $GATEAI_API_KEY y verifica que sea válida y esté configurada en Gate.AI. Si la variable se configura en otra sesión, reinicia la terminal.

Problema: Respuesta 404, fallo de conexión o endpoint no encontrado

• Causa: Configuración incorrecta de base_url. La URL correcta compatible con OpenAI es:
• Solución: Asegúrate de que cada instancia de ChatOpenAI tenga base_url configurado a la URL base proporcionada por Gate.AI.

Problema: Python lanza ModuleNotFoundError

• Causa: No se han instalado langchain-openai o langgraph en el entorno virtual activo
• Solución: Tras activar el entorno, ejecuta: pip install -U langchain langchain-openai langgraph

Problema: Autenticación exitosa pero fallo en la solicitud del modelo

• Causa: Modelo no disponible, mal escrito o no soportado en la solicitud actual
• Solución: Prueba primero con model="auto". Para fijar un modelo, copia el ID válido desde Gate.AI.

Problema: Flujo en LangGraph no devuelve estado completo

• Causa: Nodo que no devuelve las claves esperadas o estructura del grafo incompleta
• Solución: Verifica que cada nodo devuelva un diccionario con las claves correctas y que el grafo tenga START, las aristas y END correctamente configurados.

¿Qué puedes configurar o construir a continuación?

• Integrar más profundamente con la API de Gate.AI para flujos de trabajo más amplios
• Para integración en editores de código AI, consulta la guía de integración de Gate.AI Cursor
• Para flujos que involucren Claude Code o configuraciones compatibles con Anthropic, revisa la guía de integración de Gate.AI Claude Code