Output Parsers

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

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.