Python REPL

PythonREPLTool para ejecución de código

La PythonREPL es una herramienta experimental de LangChain que permite a los modelos de lenguaje ejecutar código Python de forma dinámica. 

Esta capacidad resulta especialmente interesante cuando necesitamos que el LLM realice cálculos complejos, análisis de datos o genere visualizaciones que van más allá de sus capacidades de procesamiento.

Configuración básica

Para utilizar esta herramienta, debemos importarla desde el módulo experimental de LangChain. La ubicación en el paquete experimental refleja las consideraciones de seguridad inherentes a la ejecución de código arbitrario:

from langchain_experimental.utilities import PythonREPL
from langchain_core.tools import Tool

# Python REPL (Read-Eval-Print Loop) is a tool that allows you to run Python code interactivel
python_repl = PythonREPL()

python_repl.run("print(1+1)")

Ejemplo de resultado:

Un ejemplo muy sencillo de cómo usarla con un modelo LLM sería así:

def simple_python_chain(query):
    code = llm.invoke(f"Genera código Python para: {query}. Solo código, sin explicaciones.").content
    
    if "```" in code:
        code = code.split("```")[1]
        if code.startswith("python"):
            code = code[6:]
    code = code.strip()
    
    result = python_repl.run(code)
    
    return f"Código:\n{code}\n\nResultado:\n{result}"

result = simple_python_chain("Convierte 100 fahrenheit a celsius")
print(result)

La herramienta se integra naturalmente con el sistema de tool calling de LangChain, permitiendo que el modelo decida cuándo es necesario ejecutar código Python para resolver una consulta específica. Para ello, es necesario crearla como una tool para pasarla a un modelo:

from langchain_experimental.utilities import PythonREPL
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableLambda
from langchain_core.output_parsers import StrOutputParser


python_repl = PythonREPL()
llm = ChatOpenAI(model="gpt-4o", temperature=0)


code_prompt = ChatPromptTemplate.from_template("""
Genera código Python para resolver esta pregunta. Solo devuelve el código, sin explicaciones adicionales:

Pregunta: {query}

Código Python:

{code}

""")

# Función que ejecuta el código
def execute_code(inputs):
    code = inputs["code"]
    query = inputs["query"]
    
    # Ejecutar código Python
    result = python_repl.run(code)
    
    return {
        "query": query,
        "code": code,
        "execution_result": result
    }

# Función que genera código Python
def generate_code(query):
    code_response = llm.invoke(f"""
    Genera código Python limpio para resolver: {query}
    
    Responde SOLO con el código Python, sin markdown ni explicaciones:
    """)
    
    return {
        "query": query,
        "code": code_response.content
    }

# Crear la cadena LCEL
chain = (
    RunnableLambda(generate_code)
    | RunnableLambda(execute_code)
    | RunnableLambda(lambda x: f"Pregunta: {x['query']}\n\nCódigo ejecutado:\n{x['code']}\n\nResultado:\n{x['execution_result']}")
)

# Usar
result = chain.invoke("Calcula la media de los números [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]")
print(result)

No obstante, las herramientas en LangChain se integran mejor cuando trabajamos con Agentes, esto lo veremos directamente en el curso de LangGraph.