LangChain Tutorial en Español: Crear Aplicaciones con LLMs [2026]

1pip install langchain
2pip install langchain-openai     # Para ChatGPT
3pip install langchain-community  # Integraciones
4pip install python-dotenv         # Variables de entorno

1OPENAI_API_KEY=sk-...

1from dotenv import load_dotenv
2import os
3 
4load_dotenv()
5api_key = os.getenv("OPENAI_API_KEY")

1from langchain.prompts import PromptTemplate
2 
3# Template simple
4template = """Traduce el siguiente texto al español:
5{texto_original}
6 
7Traducción:"""
8 
9prompt = PromptTemplate(
10    input_variables=["texto_original"],
11    template=template
12)
13 
14# Uso
15texto = "Hello, how are you?"
16prompt_formateado = prompt.format(texto_original=texto)
17print(prompt_formateado)

1from langchain_openai import ChatOpenAI
2from langchain.chains import LLMChain
3from langchain.prompts import PromptTemplate
4 
5# Configura el LLM
6llm = ChatOpenAI(model="gpt-4o", temperature=0.7)
7 
8# Prompt template
9template = """Eres un experto en {tema}.
10La pregunta es: {pregunta}
11 
12Respuesta detallada:"""
13 
14prompt = PromptTemplate(
15    input_variables=["tema", "pregunta"],
16    template=template
17)
18 
19# Crea la chain
20chain = LLMChain(llm=llm, prompt=prompt)
21 
22# Ejecuta
23resultado = chain.invoke({
24    "tema": "Machine Learning",
25    "pregunta": "¿Qué es overfitting?"
26})
27 
28print(resultado["text"])

1from langchain.chains import SequentialChain
2 
3# Chain 1: Genera título de artículo
4tema_template = """Genera un título creativo para un artículo sobre {tema}.
5Título:"""
6 
7tema_prompt = PromptTemplate(
8    input_variables=["tema"],
9    template=tema_template
10)
11titulo_chain = LLMChain(llm=llm, prompt=tema_prompt, output_key="titulo")
12 
13# Chain 2: Genera introducción basada en el título
14intro_template = """Basado en el título "{titulo}", escribe una introducción atractiva.
15Introducción:"""
16 
17intro_prompt = PromptTemplate(
18    input_variables=["titulo"],
19    template=intro_template
20)
21intro_chain = LLMChain(llm=llm, prompt=intro_prompt, output_key="introduccion")
22 
23# Ejecuta secuencialmente
24overall_chain = SequentialChain(
25    chains=[titulo_chain, intro_chain],
26    input_variables=["tema"],
27    output_variables=["titulo", "introduccion"]
28)
29 
30resultado = overall_chain({"tema": "Inteligencia Artificial"})
31print(resultado)

1Pregunta → LLM → Respuesta (limitada a conocimiento de entrenamiento)

1Pregunta → LLM → "Necesito buscar esto" → Ejecuta herramienta → LLM con resultados → Respuesta mejorada

1from langchain.tools import tool
2import requests
3 
4@tool
5def obtener_precio_bitcoin() -> str:
6    """Obtiene el precio actual de Bitcoin en USD."""
7    try:
8        response = requests.get("https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd")
9        data = response.json()
10        precio = data["bitcoin"]["usd"]
11        return f"El precio actual de Bitcoin es: ${precio:,.2f}"
12    except Exception as e:
13        return f"Error obteniendo precio: {e}"
14 
15@tool
16def buscar_informacion(query: str) -> str:
17    """Busca información sobre un tema."""
18    # Implementación simulada
19    return f"Información relevante sobre: {query}"
20 
21# Define las herramientas disponibles
22tools = [obtener_precio_bitcoin, buscar_informacion]

1from langchain.agents import create_react_agent, AgentExecutor
2from langchain import hub
3 
4# Usa el prompt del ReAct (Reasoning + Acting)
5react_prompt = hub.pull("hwchase17/react")
6 
7# Crea el agent
8agent = create_react_agent(llm, tools, react_prompt)
9 
10# Executor ejecuta el agent
11agent_executor = AgentExecutor(
12    agent=agent,
13    tools=tools,
14    verbose=True,  # Muestra el pensamiento del agent
15    max_iterations=5
16)
17 
18# Prueba
19resultado = agent_executor.invoke({
20    "input": "¿Cuál es el precio actual de Bitcoin? ¿Ha subido mucho este año?"
21})
22 
23print(resultado["output"])

1Thought: Necesito obtener el precio actual de Bitcoin primero.
2Action: obtener_precio_bitcoin
3Observation: El precio actual de Bitcoin es: $94,230.50
4Thought: Ahora tengo el precio. Puedo comparar con precios históricos...

1from langchain.memory import ConversationBufferMemory
2from langchain.chains import ConversationChain
3 
4memory = ConversationBufferMemory()
5 
6# Chain con memoria
7conversation = ConversationChain(
8    llm=llm,
9    memory=memory,
10    verbose=True
11)
12 
13# Primera pregunta
14print(conversation.run(input="Hola, me llamo Javier"))
15# Segunda pregunta
16print(conversation.run(input="¿Cuál es mi nombre?"))
17# El LLM recuerda que te llamas Javier

1from langchain.memory import ConversationSummaryMemory
2 
3memory = ConversationSummaryMemory(
4    llm=llm,
5    max_token_limit=300  # Limita resumen a 300 tokens
6)
7 
8conversation = ConversationChain(llm=llm, memory=memory)
9 
10# Charla larga...
11for i in range(10):
12    conversation.run(input=f"Pregunta número {i}")
13 
14# Memory automáticamente resume lo anterior

1from langchain.memory import ConversationBufferWindowMemory
2 
3memory = ConversationBufferWindowMemory(k=5)  # Últimos 5 mensajes
4 
5conversation = ConversationChain(llm=llm, memory=memory)

1pip install langchain-community
2pip install faiss-cpu  # O faiss-gpu si tienes NVIDIA
3pip install pypdf

1from langchain_community.document_loaders import PyPDFLoader
2from langchain.text_splitter import RecursiveCharacterTextSplitter
3from langchain_community.vectorstores import FAISS
4from langchain_openai import OpenAIEmbeddings
5from langchain.chains import RetrievalQA
6 
7# 1. Carga documentos
8loader = PyPDFLoader("documento.pdf")
9documents = loader.load()
10 
11# 2. Divide en chunks
12splitter = RecursiveCharacterTextSplitter(
13    chunk_size=1000,
14    chunk_overlap=200
15)
16chunks = splitter.split_documents(documents)
17 
18# 3. Crea embeddings y vector store
19embeddings = OpenAIEmbeddings()
20vector_store = FAISS.from_documents(chunks, embeddings)
21 
22# 4. Crea Q&A chain
23qa_chain = RetrievalQA.from_chain_type(
24    llm=llm,
25    chain_type="stuff",
26    retriever=vector_store.as_retriever()
27)
28 
29# 5. Consulta
30respuesta = qa_chain.invoke("¿Cuál es el tema principal del documento?")
31print(respuesta["result"])

1from langchain.schema import Document
2 
3# Carga múltiples documentos
4all_chunks = []
5for archivo in ["doc1.pdf", "doc2.pdf", "doc3.pdf"]:
6    loader = PyPDFLoader(archivo)
7    docs = loader.load()
8    chunks = splitter.split_documents(docs)
9    all_chunks.extend(chunks)
10 
11# Vector store con todos
12vector_store = FAISS.from_documents(all_chunks, embeddings)
13 
14# Búsqueda similar (antes de Q&A)
15docs_similares = vector_store.similarity_search(
16    "¿Cómo se implementa autenticación?",
17    k=3  # Top 3 documentos
18)
19 
20for doc in docs_similares:
21    print(doc.page_content[:200])
22    print("---")

1from langchain.prompts import ChatPromptTemplate
2from langchain_openai import ChatOpenAI
3 
4# Componentes
5prompt = ChatPromptTemplate.from_template(
6    "Traduce al español: {texto}"
7)
8llm = ChatOpenAI()
9 
10# Pipe (|) encadena componentes
11chain = prompt | llm
12 
13# Ejecuta
14resultado = chain.invoke({"texto": "Hello world"})
15print(resultado.content)  # "Hola mundo"

1from langchain.schema.output_parser import StrOutputParser
2import json
3 
4# Componentes
5prompt = ChatPromptTemplate.from_template(
6    """Responde en JSON con estructura:
7    {{"respuesta": "...", "confianza": 0-100}}
8 
9    Pregunta: {pregunta}"""
10)
11llm = ChatOpenAI()
12parser = StrOutputParser()
13 
14# Chain con parseo manual
15chain = prompt | llm | parser
16 
17resultado = chain.invoke({"pregunta": "¿Cuál es la capital de Francia?"})
18print(resultado)
19 
20# Parseá JSON
21respuesta_json = json.loads(resultado)
22print(f"Respuesta: {respuesta_json['respuesta']}")
23print(f"Confianza: {respuesta_json['confianza']}%")

1from langchain.schema.runnable import RunnableBranch
2 
3# Crea ramas basadas en condiciones
4clasificador_prompt = ChatPromptTemplate.from_template(
5    "Clasifica como: TECNICO, GENERAL o CREATIVO\nTexto: {texto}\nClasificación:"
6)
7 
8tecnico_chain = ChatPromptTemplate.from_template(
9    "Como experto técnico, responde: {pregunta}"
10) | llm
11 
12general_chain = ChatPromptTemplate.from_template(
13    "Responde claramente: {pregunta}"
14) | llm
15 
16creativo_chain = ChatPromptTemplate.from_template(
17    "Responde de forma creativa: {pregunta}"
18) | llm
19 
20# Branch
21branch = RunnableBranch(
22    (lambda x: "TECNICO" in x["clasificacion"], tecnico_chain),
23    (lambda x: "CREATIVO" in x["clasificacion"], creativo_chain),
24    general_chain
25)

1from langchain_openai import ChatOpenAI, OpenAIEmbeddings
2from langchain.prompts import ChatPromptTemplate
3from langchain_community.vectorstores import FAISS
4from langchain.memory import ConversationBufferMemory
5from langchain.chains import ConversationRetrievalChain
6import os
7 
8class SistemaQA:
9    def __init__(self, pdf_path: str):
10        self.llm = ChatOpenAI(model="gpt-4o", temperature=0.3)
11        self.embeddings = OpenAIEmbeddings()
12        self.memory = ConversationBufferMemory(
13            memory_key="chat_history",
14            return_messages=True
15        )
16 
17        # Carga PDF
18        from langchain_community.document_loaders import PyPDFLoader
19        from langchain.text_splitter import RecursiveCharacterTextSplitter
20 
21        loader = PyPDFLoader(pdf_path)
22        docs = loader.load()
23        splitter = RecursiveCharacterTextSplitter(chunk_size=1000)
24        chunks = splitter.split_documents(docs)
25 
26        # Vector store
27        self.vector_store = FAISS.from_documents(chunks, self.embeddings)
28        self.retriever = self.vector_store.as_retriever()
29 
30        # Chain con conversación + RAG
31        self.chain = ConversationRetrievalChain.from_llm(
32            llm=self.llm,
33            retriever=self.retriever,
34            memory=self.memory,
35            verbose=True
36        )
37 
38    def consulta(self, pregunta: str) -> str:
39        """Realiza una consulta con contexto de conversación."""
40        resultado = self.chain.invoke({"question": pregunta})
41        return resultado["answer"]
42 
43    def historial(self) -> str:
44        """Retorna el historial de conversación."""
45        return self.memory.buffer
46 
47# Uso
48qa = SistemaQA("documento.pdf")
49 
50print(qa.consulta("¿Cuál es el tema principal?"))
51print(qa.consulta("¿Puedes dar más detalles?"))  # Recuerda pregunta anterior
52print(qa.historial())

1llm = ChatOpenAI(model="gpt-4o")
2chain = LLMChain(llm=llm, prompt=prompt, verbose=True)
3 
4# Imprime prompts y respuestas
5resultado = chain.invoke({"variable": "valor"})

1os.environ["LANGCHAIN_TRACING_V2"] = "true"
2os.environ["LANGSMITH_API_KEY"] = "tu_api_key"
3 
4# Ahora todas las llamadas se registran en LangSmith

1from langchain.cache import RedisCache
2import redis
3 
4redis_client = redis.Redis.from_url("redis://localhost:6379")
5cache = RedisCache(redis_client=redis_client)
6 
7# LangChain cachea llamadas al LLM

1# Usa gpt-3.5 para desarrollo
2llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
3 
4# Cambia a gpt-4o solo en producción si es crítico
5if os.getenv("ENVIRONMENT") == "production":
6    llm = ChatOpenAI(model="gpt-4o", temperature=0.7)

1from langchain_community.llms import Ollama
2 
3llm = Ollama(model="mistral", base_url="http://localhost:11434")

1if len(memory.buffer) > 5000:  # Si el buffer es muy largo
2    summary = llm.predict(f"Resume brevemente: {memory.buffer}")
3    memory.clear()
4    memory.save_context({"input": "Resumen anterior"}, {"output": summary})

1agent_executor = AgentExecutor(
2    agent=agent,
3    tools=tools,
4    max_iterations=3  # Solo 3 pasos máximo
5)