Introducción a LangChain: Agentes, Tools y LLMs en Python

LangChain es un framework para construir aplicaciones potenciadas por LLMs. Su valor principal es simple: conectar modelos de lenguaje con herramientas del mundo real de forma estructurada.

Configuración previa

Para ejecutar este código necesitas:

uv add langchain langchain-google-genai pydantic python-dotenv requests

Usamos uv como gestor de paquetes. También necesitas un archivo .env con tu API key de Google:

GOOGLE_API_KEY=tu_api_key_aquí

Vamos a desglosar el ejemplo paso a paso.

Estructura básica

from langchain.agents import create_agent
from langchain.tools import tool
from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
from langchain.messages import HumanMessage, SystemMessage
from pydantic import BaseModel, Field
from dotenv import load_dotenv
import requests

load_dotenv()

Los componentes clave son:

• LLM: El modelo de lenguaje (aquí Gemini via Google)
• Tools: Funciones que el agente puede ejecutar
• Agent: El orquestador que decide qué tool usar según la consulta
• Messages: El formato de comunicación con el LLM

Definiendo estructuras de datos con Pydantic

Antes de crear tools, definimos modelos para datos estructurados:

class WeatherResponse(BaseModel):
    """Schema para la respuesta del clima de una ciudad."""
    weather: str = Field("Clima de la ciudad")
    message: str = Field("Mensaje que se imprimirá al usuario")
    city: str = Field("Ciudad de la petición del usuario")

Pydantic no es opcional aquí: LangChain lo usa para validar inputs/outputs y dar al LLM schemas claros de qué datos esperar.

Creando Tools

Las tools son funciones Python decoradas con @tool. El LLM las usa cuando decide que necesita información externa:

@tool
def get_weather(city: str) -> str:
    """Obtiene el clima para una ciudad dada."""
    result = requests.get("https://wttr.in/" + city + "?format=j1")
    json = result.json()
    weather = json["current_condition"][0]["weatherDesc"][0]["value"]
    return weather

Punto clave: el docstring es CRÍTICO. El LLM lo usa para entender CUÁNDO llamar a esa tool. Si el docstring es vago, el agente no sabrá cuándo usarla.

Configurando el LLM

llm = ChatGoogleGenerativeAI(model="gemini-3.5-flash-lite")

Creando y ejecutando el Agente

tools = [get_weather]
agent = create_agent(model=llm, tools=tools, response_format=WeatherResponse)

result = agent.invoke({
    "messages": [
        SystemMessage(content="Eres un asistente útil que puede responder preguntas sobre el clima."),
        HumanMessage(content="¿Qué tiempo hace en Madrid?")
    ]
})
print(result["structured_response"].message)

create_agent recibe:

• model: el LLM a usar
• tools: lista de tools disponibles
• response_format: esquema de respuesta estructurada (Pydantic)

El agente decide automáticamente qué tool llamar basándose en la pregunta del usuario.

Flujo completo

Usuario pregunta → Agent analiza → Decide tool → Ejecuta tool → LLM interpreta resultado → Respuesta estructurada

En nuestro ejemplo:

1. Preguntamos “¿Qué tiempo hace en Madrid?”
2. El agent reconoce que necesita el clima
3. Llama a get_weather("Madrid")
4. Recibe “fog”
5. Lo formatea en el esquema WeatherResponse

Ejecutando el ejemplo

Para ejecutar el código, en el directorio del proyecto:

uv run main.py

Salida real:

The weather in Madrid is currently fog.

Limitaciones y siguiente paso

Este ejemplo es simple a propósito: una tool, un agente, una pregunta. Pero ilustra los bloques fundamentales.

Donde LangChain brilla es cuando tienes múltiples tools y el agente debe decidir cuál usar, o cuando encadenas varias llamadas. Pero para muchos casos, una tool + un buen prompt es suficiente.

---

Tags: langchain, python, ia, llm, agentes