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.

Instalación y configuración

La herramienta se encuentra en el paquete experimental de LangChain. Esta ubicación refleja las consideraciones de seguridad inherentes a la ejecución de código arbitrario:

pip install langchain-experimental langchain-openai

Uso básico

Para utilizar la herramienta, importamos PythonREPL desde el módulo experimental:

from langchain_experimental.utilities import PythonREPL

# Crear instancia del REPL
python_repl = PythonREPL()

# Ejecutar código Python simple
resultado = python_repl.run("print(1 + 1)")
print(resultado)  # Output: 2

El REPL (Read-Eval-Print Loop) permite ejecutar código Python de forma interactiva y capturar los resultados.

Ejemplo con cálculos matemáticos

Uno de los casos de uso más comunes es realizar cálculos matemáticos que el modelo no puede hacer de forma nativa:

from langchain_experimental.utilities import PythonREPL

python_repl = PythonREPL()

# Cálculos complejos
codigo = """
import math

# Cálculo de interés compuesto
capital = 10000
tasa = 0.05
tiempo = 10

monto_final = capital * (1 + tasa) ** tiempo
print(f"Monto final: ${monto_final:.2f}")
"""

resultado = python_repl.run(codigo)
print(resultado)

Integración con modelos LLM

Un ejemplo sencillo de cómo usar PythonREPL con un modelo LLM:

from langchain_experimental.utilities import PythonREPL
from langchain_openai import ChatOpenAI

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

def simple_python_chain(query):
    # Generar código Python
    code = llm.invoke(
        f"Genera código Python para: {query}. Solo código, sin explicaciones."
    ).content
    
    # Limpiar el código si viene con markdown
    if "```" in code:
        code = code.split("```")[1]
        if code.startswith("python"):
            code = code[6:]
    code = code.strip()
    
    # Ejecutar el código
    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)

Construcción de cadenas LCEL

Para integrar PythonREPL en cadenas más complejas usando LCEL:

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 ni markdown.

Pregunta: {query}

Código Python:
""")

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
    }

def generate_code(query):
    code_response = llm.invoke(
        f"Genera código Python limpio para resolver: {query}\n"
        "Responde SOLO con el código Python, sin markdown:"
    )
    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:\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)

Consideraciones de seguridad

La ejecución de código arbitrario presenta riesgos significativos de seguridad que deben abordarse antes de usar PythonREPL en producción.

Riesgos principales

• Ejecución de código malicioso: El modelo podría generar código que acceda a archivos del sistema, ejecute comandos de shell o realice operaciones destructivas
• Consumo de recursos: Código con bucles infinitos o alto consumo de memoria puede bloquear el sistema
• Filtración de información: El código podría acceder a variables de entorno o archivos sensibles

Mitigación de riesgos

Sandbox de ejecución: La mejor práctica es ejecutar el código en un entorno aislado:

from langchain_experimental.utilities import PythonREPL
import subprocess
import tempfile
import os

def ejecutar_codigo_seguro(codigo: str, timeout: int = 10) -> str:
    """Ejecuta código Python con restricciones de tiempo"""
    try:
        # Crear archivo temporal
        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
            f.write(codigo)
            temp_file = f.name
        
        # Ejecutar con timeout
        result = subprocess.run(
            ['python', temp_file],
            capture_output=True,
            text=True,
            timeout=timeout
        )
        
        # Limpiar archivo temporal
        os.unlink(temp_file)
        
        if result.returncode == 0:
            return result.stdout
        return f"Error: {result.stderr}"
        
    except subprocess.TimeoutExpired:
        return "Error: Tiempo de ejecución excedido"
    except Exception as e:
        return f"Error: {str(e)}"

Validación de código: Puedes validar el código antes de ejecutarlo:

def validar_codigo(codigo: str) -> bool:
    """Valida que el código no contenga operaciones peligrosas"""
    palabras_prohibidas = [
        'os.system', 'subprocess', 'exec(', 'eval(',
        '__import__', 'open(', 'file(', 'input(',
        'os.remove', 'os.rmdir', 'shutil.rmtree'
    ]
    
    for palabra in palabras_prohibidas:
        if palabra in codigo:
            return False
    return True

def ejecutar_con_validacion(codigo: str) -> str:
    python_repl = PythonREPL()
    
    if not validar_codigo(codigo):
        return "Error: Código contiene operaciones no permitidas"
    
    return python_repl.run(codigo)

Uso recomendado

La herramienta PythonREPL es más adecuada para:

• Desarrollo y pruebas: Entornos controlados donde el riesgo es aceptable
• Cálculos matemáticos: Operaciones numéricas sin acceso a recursos del sistema
• Análisis de datos: Procesamiento de datos proporcionados directamente en el código

Para entornos de producción, considera usar alternativas más seguras como:

• Code Interpreter de OpenAI: Sandbox integrado y seguro
• Contenedores Docker: Aislamiento completo del sistema
• Entornos virtuales restringidos: Con permisos limitados

Integración con agentes

Las herramientas en LangChain se integran mejor cuando trabajamos con agentes. El uso de PythonREPL con agentes se verá en detalle en el módulo de LangGraph, donde el bucle de ejecución de herramientas se maneja automáticamente con mayor control sobre la seguridad y los reintentos.