Output parsers en LangChain
Los output parsers son componentes fundamentales en LangChain que se encargan de transformar las respuestas en texto plano de los modelos de lenguaje en formatos estructurados y útiles para nuestras aplicaciones. Cuando trabajamos con modelos como GPT-4, las respuestas llegan como cadenas de texto, pero frecuentemente necesitamos convertir esa información en tipos de datos específicos como listas, diccionarios o estructuras más complejas.
LangChain proporciona una amplia variedad de parsers predefinidos que cubren los casos de uso más comunes, desde la simple extracción de texto hasta la conversión en listas separadas por comas. Estos parsers no solo transforman el output, sino que también pueden generar instrucciones de formato que se incluyen en el prompt para guiar al modelo hacia la estructura deseada.
Funcionamiento básico de los output parsers
Todos los output parsers en LangChain heredan de la clase base BaseOutputParser
y implementan dos métodos principales: parse()
para procesar la respuesta del modelo y get_format_instructions()
para generar las instrucciones que se añaden al prompt.
El flujo típico de trabajo con un output parser sigue este patrón: primero obtenemos las instrucciones de formato del parser, las incluimos en nuestro prompt, enviamos la consulta al modelo y finalmente procesamos la respuesta con el método parse()
.
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
# Configurar el modelo
llm = ChatOpenAI(model="gpt-4")
# Crear el parser
parser = StrOutputParser()
# Generar respuesta del modelo
response = llm.invoke("¿Cuál es la capital de Francia?")
# Procesar la respuesta
resultado = parser.parse(response.content)
print(resultado) # "París"
StrOutputParser: el parser más básico
El StrOutputParser
es el parser más simple y fundamental de LangChain. Su función principal es extraer el contenido de texto de la respuesta del modelo, eliminando metadatos y estructuras adicionales que puedan acompañar a la respuesta.
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4")
parser = StrOutputParser()
# El modelo devuelve un objeto AIMessage
response = llm.invoke("Explica qué es Python en una línea")
print(type(response)) # <class 'langchain_core.messages.ai.AIMessage'>
# El parser extrae solo el contenido de texto
texto_limpio = parser.parse(response.content)
print(type(texto_limpio)) # <class 'str'>
print(texto_limpio) # "Python es un lenguaje de programación..."
Este parser es especialmente útil cuando necesitamos trabajar con respuestas de texto simple sin estructuras complejas, y queremos asegurarnos de obtener únicamente el contenido relevante sin metadatos adicionales.
CommaSeparatedListOutputParser: creando listas estructuradas
El CommaSeparatedListOutputParser
transforma respuestas de texto en listas de elementos separados por comas. Este parser es particularmente valioso cuando necesitamos que el modelo genere múltiples elementos relacionados de forma estructurada.
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4")
parser = CommaSeparatedListOutputParser()
# Obtener las instrucciones de formato
instrucciones = parser.get_format_instructions()
print(instrucciones)
# "Your response should be a list of comma separated values, eg: `foo, bar, baz`"
# Crear el prompt incluyendo las instrucciones
prompt = f"""
Lista 5 lenguajes de programación populares.
{instrucciones}
"""
# Generar y procesar la respuesta
response = llm.invoke(prompt)
lista_lenguajes = parser.parse(response.content)
print(type(lista_lenguajes)) # <class 'list'>
print(lista_lenguajes) # ['Python', 'JavaScript', 'Java', 'C++', 'Go']
El parser maneja automáticamente la limpieza de espacios y la conversión a lista, eliminando espacios en blanco innecesarios alrededor de cada elemento.
Manejo de errores en output parsers
Los output parsers pueden encontrar respuestas malformadas que no siguen el formato esperado. LangChain proporciona mecanismos para manejar estos casos de forma elegante.
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_core.exceptions import OutputParserException
parser = CommaSeparatedListOutputParser()
# Respuesta bien formateada
respuesta_correcta = "Python, Java, C++, JavaScript"
resultado = parser.parse(respuesta_correcta)
print(resultado) # ['Python', 'Java', 'C++', 'JavaScript']
# Respuesta malformateada
respuesta_incorrecta = "Los lenguajes son: Python y Java principalmente"
try:
resultado_error = parser.parse(respuesta_incorrecta)
print(resultado_error)
except OutputParserException as e:
print(f"Error de parsing: {e}")
# Manejar el error o usar un valor por defecto
resultado_fallback = ["Python", "Java"]
Personalización de separadores
Guarda tu progreso
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
Aunque el CommaSeparatedListOutputParser
usa comas por defecto, podemos personalizar el comportamiento para trabajar con diferentes separadores según nuestras necesidades específicas.
from langchain_core.output_parsers import CommaSeparatedListOutputParser
# Parser estándar con comas
parser_comas = CommaSeparatedListOutputParser()
# Procesar lista con diferentes formatos
respuesta1 = "Python, Java, C++"
respuesta2 = "Python,Java,C++" # Sin espacios
respuesta3 = "Python , Java , C++" # Espacios extra
# Todos estos casos se manejan correctamente
for respuesta in [respuesta1, respuesta2, respuesta3]:
resultado = parser_comas.parse(respuesta)
print(resultado) # ['Python', 'Java', 'C++'] en todos los casos
Combinando parsers con diferentes tipos de consultas
Los output parsers se adaptan a diferentes contextos y tipos de consultas, desde listas simples hasta respuestas más complejas que requieren estructuración específica.
from langchain_core.output_parsers import CommaSeparatedListOutputParser
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4")
parser = CommaSeparatedListOutputParser()
# Ejemplo 1: Tecnologías
prompt_tech = f"""
¿Qué tecnologías se usan típicamente en desarrollo web frontend?
{parser.get_format_instructions()}
"""
tecnologias = parser.parse(llm.invoke(prompt_tech).content)
print("Tecnologías frontend:", tecnologias)
# Ejemplo 2: Ingredientes de receta
prompt_receta = f"""
Lista los ingredientes principales para hacer una tortilla española.
{parser.get_format_instructions()}
"""
ingredientes = parser.parse(llm.invoke(prompt_receta).content)
print("Ingredientes:", ingredientes)
# Ejemplo 3: Pasos de proceso
prompt_pasos = f"""
¿Cuáles son las fases principales del ciclo de vida del software?
{parser.get_format_instructions()}
"""
fases = parser.parse(llm.invoke(prompt_pasos).content)
print("Fases del desarrollo:", fases)
Esta flexibilidad hace que los output parsers sean herramientas versátiles para estructurar información en una amplia variedad de dominios y aplicaciones, manteniendo siempre la consistencia en el formato de salida independientemente del contenido específico de la consulta.
Aprendizajes de esta lección
- Comprender qué son los output parsers y su función en LangChain.
- Aprender a utilizar parsers básicos como StrOutputParser para extraer texto limpio.
- Conocer el funcionamiento del CommaSeparatedListOutputParser para convertir respuestas en listas.
- Manejar errores comunes en el parsing de respuestas malformadas.
- Aplicar la personalización y combinación de parsers en distintos contextos y tipos de consultas.
Completa LangChain y certifícate
Únete a nuestra plataforma y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs