José Miguel Amaya — construyendo con LLMs

• CTO y socio fundador de Xprende Tech. Full Stack Engineer en Efilm Online.
• Fundador de Piura AI, Tallanix, Python Piura y VICUX.
• Especialista en Python, Django/FastAPI e IA (LangChain, LangGraph, RAG).
• Autor de charlas y talleres de IA aplicada en Python Piura y Piura AI.

comunidad

empresa

“¿Quién ha peleado con un bot de soporte hecho con LLMs?”

Hoy resolvemos esto construyendo SoporteBot, pieza por pieza.

Al terminar podrás…

• Crear un chat model y componerlo con promptsmodelos
• Forzar salidas estructuradas para clasificar y extraerdatos
• Montar búsqueda semántica y una cadena RAGconocimiento
• Construir un agente con herramientas, memoria y middlewareagentes

¿Qué son los LLMs?

Los modelos de lenguaje a gran escala son modelos de machine learning que sobresalen en tareas relacionadas con el lenguaje: generación de texto, traducción, resumen, respuesta a preguntas, entre otras.

Suelen usarse a través de una interfaz de modelo de chat: recibe una lista de mensajes y devuelve un mensaje como salida.

Capacidades de los LLMs modernos

¿Qué es LangChain?

Es un framework para desarrollar aplicaciones basadas en LLMs. Simplifica cada etapa del ciclo de vida de la aplicación y da una interfaz uniforme para trabajar con modelos de distintos proveedores.

Anatomía de SoporteBot

Toda aplicación se arma con las mismas piezas: un modelo que razona, herramientas que ejecutan acciones y un prompt que da contexto.

Todo se compone: los Runnables

Prompts, modelos y parsers son Runnables: piezas con los mismos métodos que se encadenan con el operador |. Esto es LCEL, el Lenguaje de Expresión LangChain.

cadena = prompt | model | StrOutputParser()   # todos son Runnables

cadena.invoke(datos)            # una vez
cadena.batch([d1, d2])          # en lote
for c in cadena.stream(datos):  # en vivo
    print(c, end="")

La misma cadena tiene invoke, stream y batch sin escribir nada extra.

El ecosistema LangChain

LangGraph, despliegue y LangSmith

El modelo de chat

• init_chat_model("proveedor:modelo") crea un modelo de cualquier proveedor con una sola función.
• Por debajo, cada proveedor expone una clase con prefijo “Chat”: ChatOpenAI, ChatAnthropic, ChatOllama.
• Todas heredan de BaseChatModel: misma interfaz de streaming, asincronía y batching.

model = init_chat_model("gpt-5-nano", model_provider="openai", temperature=0)

model.invoke("Resume este ticket: mi pedido no llegó.")   # una respuesta

for chunk in model.stream("Escribe una disculpa breve."):
    print(chunk.text, end="")                              # streaming en vivo

model.batch(["Hola", "Gracias", "Adiós"])                 # varias a la vez

Parámetros estándar

Métodos principales

Mensajes en código

from langchain.messages import (
    SystemMessage, HumanMessage, AIMessage)

mensajes = [
    SystemMessage("Eres el soporte de TiendaPiura."),
    HumanMessage("Mi pedido #12345 no llegó."),
    AIMessage("Lamento el retraso, lo reviso."),
]

mensajes = [
    {"role": "system", "content": "Eres el soporte."},
    {"role": "user", "content": "Mi pedido no llegó."},
    {"role": "assistant", "content": "Lo reviso."},
]

El cuarto rol, tool (ToolMessage), lleva el resultado de una herramienta de vuelta al modelo. Lo veremos en agentes.

Prompt Templates

• Transforman la entrada del usuario y parámetros en instrucciones para el modelo.
• Reciben un diccionario donde cada clave rellena una variable.
• Devuelven un PromptValue, que se pasa al modelo; también se puede convertir a string o a lista de mensajes.

MessagesPlaceholder

Inserta una lista de mensajes en un punto específico del prompt. Es la pieza clave para inyectar el historial de una conversación.

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt = ChatPromptTemplate.from_messages([
    ("system", "Eres el soporte de TiendaPiura."),
    MessagesPlaceholder("historial"),
    ("human", "{pregunta}"),
])

Outputs estructurados

Cómo se implementa

Errores comunes

¿Qué es un motor de búsqueda semántica?

Es un sistema que busca y recupera información basada en el significado o contexto de una consulta, no en palabras exactas.

Embeddings: el significado como vector

Un embedding convierte texto en números (un vector). Textos con significado parecido quedan cerca en ese espacio.

La búsqueda compara el vector de la consulta con los de los fragmentos del manual.

Chunking: dividir el manual

Una página es demasiado grande para buscar. La partimos en fragmentos con solapamiento para no cortar ideas.

El solapamiento (naranja) evita perder frases que cruzan el corte.

Retrieval-Augmented Generation

El modelo usa información recuperada de fuentes externas para responder, combinando su conocimiento general con tus datos. Tres piezas: cargar (Document), vectorizar (embeddings) y almacenar (vector store).

¿Qué es un agente?

Un agente es un modelo que decide qué herramienta usar y repite el ciclo hasta resolver la tarea. No es una cadena fija: el modelo elige el camino.

Herramientas con @tool

Una herramienta es una función con nombre, descripción y argumentos tipados. El modelo las ve como capacidades disponibles.

from langchain.tools import tool

@tool
def consultar_pedido(numero: str) -> str:
    """Devuelve el estado de un pedido por su número."""
    return "Pedido #12345: en tránsito, llega mañana."

@tool
def buscar_en_manual(consulta: str) -> str:
    """Busca en el manual de políticas de la tienda."""
    return retriever.invoke(consulta)[0].page_content

El modelo pide herramientas: bind_tools

from langchain.tools import tool
from langchain.chat_models import init_chat_model

@tool
def consultar_pedido(numero: str) -> str:
    """Devuelve el estado de un pedido."""
    return "en tránsito"

model = init_chat_model("gpt-5-nano", model_provider="openai")
model_con_tools = model.bind_tools([consultar_pedido])

resp = model_con_tools.invoke("¿Dónde está mi pedido #12345?")
resp.tool_calls  # [{'name': 'consultar_pedido', 'args': {'numero': '12345'}}]

El modelo pide la herramienta; ejecutarla y devolver el resultado sigue siendo tu trabajo. Eso es justo lo que automatiza create_agent.

create_agent: el bucle completo

from langchain.agents import create_agent

agente = create_agent(
    model=model,
    tools=[consultar_pedido, buscar_en_manual],
    system_prompt="Eres el soporte de TiendaPiura. No inventes datos.",
)

agente.invoke({"messages": [
    {"role": "user", "content": "¿Dónde está mi pedido #12345?"},
]})

Qué pasa por dentro

La conversación del agente es una secuencia de mensajes. Los roles assistant y tool hacen el trabajo:

Agentic RAG: buscar es una herramienta

from langchain.tools import tool

@tool
def buscar_en_manual(consulta: str) -> str:
    """Busca en el manual de políticas de la tienda."""
    docs = retriever.invoke(consulta)
    return "\n\n".join(d.page_content for d in docs)

agente = create_agent(
    model=model,
    tools=[buscar_en_manual, consultar_pedido],
    system_prompt="Consulta el manual antes de responder políticas.",
)

Diferencia: en el 2-step RAG siempre se busca; aquí el agente decide si necesita el manual.

Cadena o agente: cuándo usar cada uno

SoporteBot, de principio a fin

Recursos