Cómo implementar su primer agente de Langgraph en TrueFoundry

En esta guía, le mostraremos cómo implementar un Langgraph agente en True Foundry, una plataforma diseñada para simplificar la implementación de la IA con una experiencia mínima en DevOps o MLOps. TrueFoundry automatiza la administración, el escalado y la supervisión de la infraestructura, lo que le permite centrarse en obtener información en lugar de gestionar las complejidades de la implementación. Con solo unos pocos clics, puede transformar las solicitudes en lenguaje natural en consultas SQL y gráficos dinámicos, lo que hace que la exploración de datos sea fluida e inteligente. ¡No es necesario realizar consultas manuales!

Si quieres probarlo directamente, visita la plataforma TrueFoundry y navega hasta Live Demos y Langgraph-Streamlit: Demostración en vivo del flujo de trabajo de nuestros agentes

Descripción general de la arquitectura

Este proyecto consta de varios componentes clave que trabajan en conjunto:

Agente de consultas

• Utiliza GPT-4o para la comprensión del lenguaje natural
• Genera las consultas SQL adecuadas para ClickHouse
• Ejecuta la consulta SQL en una base de datos preconfigurada
• Devuelve los datos en formato tabular como entrada para el agente de visualización

Agente de visualización: Un segundo agente de IA que

• Determina el tipo de visualización más apropiado teniendo en cuenta los datos
• Genera gráficos usando matplotlib/seaborn
• Maneja el formato y el estilo de las visualizaciones

Backend de FastAPI: API RESTful que

• Coordina entre agentes mediante Langgraph
• Gestiona el procesamiento asincrónico de trabajos
• Sirve imágenes y resultados de la trama

Interfaz optimizada: Interfaz de usuario que

• Proporciona una interfaz de consulta intuitiva
• Muestra el estado del procesamiento en tiempo real
• Muestra visualizaciones interactivas

‍

Flujo de datos

1. El usuario envía una consulta en lenguaje natural a través de la interfaz de usuario Streamlit
2. El agente SQL procesa la consulta para generar SQL
3. SQL se ejecuta en la base de datos de ClickHouse
4. Los resultados se pasan a Plot Agent
5. Plot Agent crea las parcelas apropiadas
6. Los resultados se muestran en la interfaz de usuario de Streamlit

‍Cómo empezar

Clonar el repositorio

En primer lugar, navegue hasta el Ejemplos de introducción a TrueFoundry reposicionarlo y clonarlo:

git clone <https://github.com/truefoundry/getting-started-examples.git>

Navegue hasta el directorio de agentes gráficos

Cambie al directorio plot_agent:

cd getting-started-examples/plot_agent/langgraph_plot_agent

Configuración del entorno

Para crear y activar un entorno virtual:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

Instalar dependencias

pip install -r requirements.txt

Configuración del entorno

Copie el archivo de entorno de ejemplo:

```bash
cp .env.example .env
```

Crea un .env archiva con tus credenciales

# Truefoundry LLMGateway Configuration if using Truefoundry LLM Gateway for calling models
LLM_GATEWAY_BASE_URL=your_llm_gateway_base_url_here
LLM_GATEWAY_API_KEY=your_llm_gateway_api_key_here

# OPENAI API Configuration if not using Truefoundry LLM Gateway
OPENAI_API_KEY=<your_openai_api_key_here>

# ClickHouse Database Configuration
CLICKHOUSE_HOST=your_clickhouse_host_here
CLICKHOUSE_PORT=443
CLICKHOUSE_USER=your_clickhouse_user_here
CLICKHOUSE_PASSWORD=your_clickhouse_password_here
CLICKHOUSE_DATABASE=default

Nota: Al utilizar TrueFoundry LLM Gateway, el formato de ID del modelo debe ser nombre-proveedor/nombre-modelo (p. ej., openai-main/gpt-4o). Asegúrese de que su .env El archivo contiene las credenciales correctas de LLM Gateway, tal como se muestra en la sección Configuración del entorno.

Para obtener las credenciales de Clickhouse, cree una cuenta en Clickhouse, inicia sesión y crea un servicio. Tras hacer clic en el servicio, verás un botón de conexión en el centro de la barra lateral izquierda, en el que podrás hacer clic para ver las credenciales, tal y como se muestra a continuación. Puedes crear una base de datos cargando tus archivos o usar una base de datos predefinida.

Implementación de Langgraph Agent

El proyecto utiliza dos agentes de LangGraph, lo que también lo convierte en una referencia práctica útil a la hora de evaluar AutoGen frente a LangGraph para el diseño de flujos de trabajo de múltiples agentes. Si prefiere usar solo openai, sustituya:

model=OpenAIChat(
        id="openai-main/gpt-4o",  # Format: provider-name/model-name
        api_key=os.getenv("LLM_GATEWAY_API_KEY"),
        base_url=os.getenv("LLM_GATEWAY_BASE_URL")
    ),

Con:

model=OpenAIChat(
        id="gpt-4o",  # Specify model here
        api_key=os.getenv("OPENAI_API_KEY")
      ),

Así es como se configuran en una configuración en la que Langflow frente a LangGraph a menudo se basa en opciones de orquestación.

class State(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]

tools_list = [execute_clickhouse_query, create_plot]

def tools_condition_modified(state):
    ans = tools_condition(state)
    human_messages_id = [m.id for m in state["messages"] if m.type == "human"]
    if ans == "tools":
        return "tools"
    else:
        return "__end__"

def create_agent():
    builder = StateGraph(State)

    llm = ChatOpenAI(
        model=os.getenv("MODEL_ID"), 
        api_key=os.getenv("LLM_GATEWAY_API_KEY"), 
        base_url=os.getenv("LLM_GATEWAY_BASE_URL"),
        streaming=True  # Enable streaming for the LLM
    )

    llm.bind_tools(tools_list)

    # Define nodes: these do the work
    builder.add_node("assistant", llm)
    builder.add_node("tools", ToolNode(tools_list))

    # Define edges: these determine how the control flow moves
    builder.add_edge(START, "assistant")
    builder.add_edge("tools", "assistant")
    builder.add_conditional_edges(
        "assistant",
        tools_condition_modified,
    )
    builder.add_edge("assistant", "__end__")

    agent = builder.compile()
    return agent

agent = create_agent()

Ejecución de los servicios

Inicie el servidor FastAPI:

python api.py

Inicie Streamlit UI (nueva terminal):

streamlit run app.py

Despliegue en TrueFoundry

Prerrequisitos

Instale la CLI de TrueFoundry:

pip install -U "truefoundry"

Inicie sesión en TrueFoundry:

tfy login --host "<https://app.truefoundry.com>"

Pasos de implementación

1. Navegue hasta la sección de despliegues en TrueFoundry.

2. Haz clic en Servicio en la parte inferior.
3. Selecciona el espacio de trabajo de tu clúster.
4. Puedes realizar la implementación desde tu portátil, GitHub o Docker. Si realizas la implementación desde tu portátil, asegúrate de haber completado los requisitos previos anteriores.
5. La plataforma TrueFoundry generará un archivo deploy.py y lo añadirá a su proyecto. Tendrás que editar este archivo para añadir tus variables de entorno. Busca la sección env en el archivo generado y agrega tus credenciales:

# In the generated deploy.py file, locate the env section and add your variables:  
  env={
      # If using OPENAI  
      "OPENAI_API_KEY": "your_openai_api_key",  
      # If using LLM_GATEWAY
      "LLM_GATEWAY_API_KEY": "your_llm_gateway_api_key",
      "LLM_GATEWAY_BASE_URL": "your_llm_gateway_base_url",
      "CLICKHOUSE_HOST": "your_clickhouse_host",  
      "CLICKHOUSE_PORT": "443",  
      "CLICKHOUSE_USER": "your_user",  
      "CLICKHOUSE_PASSWORD": "your_password",  
      "CLICKHOUSE_DATABASE": "default",  
      "MODEL_ID": "gpt-4o"  
  },  

Asegúrese de reemplazar los valores de los marcadores de posición por sus credenciales reales. Sin estas variables de entorno, la aplicación no funcionará correctamente.

6. Ejecute el comando de despliegue:

python deploy.py

¡Su API de flujo de trabajo de SQL y Plot ya está implementada y ejecutándose en TrueFoundry!

7. Para confirmar que todo funciona, puedes enviar una consulta de prueba usando curl:

curl -X POST -H "Content-Type: application/json" \  
  -d '{"query": "Show me the cost trends by model over the last week"}' \  
  https://Langgraph-plot-agent-demo-8000.aws.demo.truefoundry.cloud/query  

Si todo está configurado correctamente, deberías recibir una respuesta como:

{  
  "job_id": "123e4567-e89b-12d3-a456-426614174000",  
  "status": "processing",  
  "message": "Query is being processed. Check status with /status/{job_id}"  
}  

Monitorización y administración

Acceda al panel de control de TrueFoundry para:

• Supervise el uso de recursos
• Ver los registros de las aplicaciones
• Amplíe los recursos según sea necesario
• Configurar reglas de escalado automático

Compruebe el estado de la aplicación:

• Estado del backend: /health
• Documentación de la API: /docs
• Métricas: /metrics

Ejemplo de uso:

1. Enviar una consulta a través de la API:

curl -X POST "https://plot-agent-8000.your-workspace.truefoundry.cloud/query" \  
     -H "Content-Type: application/json" \  
     -d '{"query": "Show me the cost trends by model over the last week"}'  

2. A través de la interfaz de usuario Streamlit:

• Navega hasta la URL de la interfaz de usuario
• Introduzca su consulta en la entrada de texto
• Ver el procesamiento y los resultados de las consultas en tiempo real

Puntos finales de API

Enviar una consulta

curl -X POST http://localhost:8000/query \  
  -H "Content-Type: application/json" \  
  -d '{"query": "Show me the cost trends by model over the last week. Filter models that show a 0 cost."}'  

‍

Respuesta

{  
  "job_id": "123e4567-e89b-12d3-a456-426614174000",  
  "status": "processing",  
  "message": "Query is being processed. Check status with /status/{job_id}"  
}  

‍

Verificar el estado del trabajo

curl -X GET http://localhost:8000/status/123e4567-e89b-12d3-a456-426614174000  

‍

Obtener imagen de la trama

curl -X GET http://localhost:8000/plot/123e4567-e89b-12d3-a456-426614174000 --output plot.png  

Implementación de Streamlit por separado

Para garantizar una comunicación adecuada entre FastAPI y Streamlit, debe implementar Streamlit como un servicio independiente en la plataforma TrueFoundry.

1. Implemente la interfaz Streamlit por separado de FastAPI en TrueFoundry.
2. Configure CORS en FastAPI:

from fastapi.middleware.cors import CORSMiddleware  

app.add_middleware(  
    CORSMiddleware,  
    allow_origins=["*"],  
    allow_credentials=True,  
    allow_methods=["*"],  
    allow_headers=["*"],  
)  

3. Definir una variable de entorno en Streamlit

Tu aplicación Streamlit debe usar una variable de entorno para apuntar al backend de FastAPI: En tu Entorno optimizado configuración:

FASTAPI_ENDPOINT="https://langgraph-plot-agent-demo-8000.aws.demo.truefoundry.cloud"

A continuación, modifique su Aplicación Streamlit para leer esta variable de entorno:

import os

FASTAPI_ENDPOINT = os.getenv("FASTAPI_ENDPOINT", "http://localhost:8000")

Esto garantiza que Streamlit haga referencia de forma dinámica a la instancia de FastAPI correcta.

4. Utilice puertos separados

Si se implementa localmente o si TrueFoundry no gestiona automáticamente los conflictos de puertos, asegúrese FastAPI y Streamlit se ejecutan en puertos separados.

Ejemplo:

API rápida: https://langgraph-plot-agent-demo-8000.aws.demo.truefoundry.cloud

Streamlit: https://langgraph-streamlit-demo-8501.aws.demo.truefoundry.cloud

Para ejecutar Streamlit en un puerto diferente de forma local:

streamlit run app.py --server.port 8501

Añade trazas a tu agente

El rastreo te ayuda a entender lo que ocurre de manera clandestina cuando se llama a un agente. Cuando ejecutas tu agente con la función de rastreo de Truefoundry, solo tienes que añadir muy pocas líneas de código para entender la ruta, las herramientas, las llamadas realizadas, el contexto utilizado y la latencia que se sigue.

Debe instalar lo siguiente

 pip install traceloop-sdk

Y, a continuación, añada las variables de entorno necesarias para habilitar el rastreo

"TRACELOOP_BASE_URL": "<your_host_name>/api/otel" # "https://internal.devtest.truefoundry.tech/api/otel"
"TRACELOOP_HEADERS"="Authorization=Bearer%20<your_tfy_api_key>"

En su base de código donde define su agente, solo necesita estas líneas para habilitar el rastreo

from traceloop.sdk import Traceloop
Traceloop.init(app_name="langraph")

Notas finales

Después de implementar ambos servicios, asegúrese de:

• Pruebe la conectividad de la API de Streamlit a FastAPI.
• Actualiza Streamlit's .env archivo con el punto final de FastAPI correcto.
• Confirme que la configuración de CORS permita las solicitudes de Streamlit.

Esto garantiza que su API de flujo de trabajo de SQL y Plot funcione correctamente en ambos servicios.

‍

‍