Requests HTTP

RequestsGetTool y RequestsPostTool

Las herramientas HTTP de LangChain proporcionan una interfaz directa para que los modelos de lenguaje puedan interactuar con APIs REST externas. Estas herramientas transforman las capacidades de los LLMs, permitiéndoles acceder a datos en tiempo real y realizar operaciones sobre servicios web.

La biblioteca langchain_community incluye herramientas especializadas para los métodos HTTP más comunes, siendo RequestsGetTool y RequestsPostTool las fundamentales para la mayoría de integraciones con APIs RESTful.

Configuración básica de RequestsGetTool

La RequestsGetTool permite a los LLMs realizar peticiones GET para obtener información de APIs externas:

from langchain_community.tools import RequestsGetTool
from langchain_community.utilities import TextRequestsWrapper
from langchain_openai import ChatOpenAI
import os

# Configurar el wrapper para manejar respuestas HTTP
requests_wrapper = TextRequestsWrapper()

# Crear la herramienta GET
get_tool = RequestsGetTool(
    requests_wrapper=requests_wrapper,
    allow_dangerous_requests=True  # Necesario para habilitar la herramienta
)

# Configurar el modelo
llm = ChatOpenAI(model="gpt-4o", temperature=0)

El parámetro allow_dangerous_requests debe establecerse como True para habilitar la funcionalidad, ya que LangChain considera estas herramientas potencialmente peligrosas por su capacidad de realizar peticiones HTTP arbitrarias.

Uso práctico de RequestsGetTool

Para demostrar el funcionamiento, utilizaremos la API pública JSONPlaceholder:

# Ejemplo de uso directo de la herramienta
response = get_tool.invoke({
    "url": "https://jsonplaceholder.typicode.com/posts/1"
})

print(response)

Para integrar la herramienta con un modelo:

from langchain.messages import HumanMessage, SystemMessage
from langchain_core.prompts import ChatPromptTemplate

# Crear un prompt que incluya la herramienta
prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content="Eres un asistente que puede consultar APIs."),
    HumanMessage(content="{question}")
])

# Vincular la herramienta al modelo
llm_with_tools = llm.bind_tools([get_tool])

# Crear una cadena LCEL
chain = prompt | llm_with_tools

# Ejemplo de consulta
result = chain.invoke({
    "question": "Obtén información del post con ID 2 de JSONPlaceholder"
})

print(result.content)

Configuración de RequestsPostTool

La RequestsPostTool permite realizar peticiones POST para enviar datos a APIs externas:

from langchain_community.tools import RequestsPostTool

# Crear la herramienta POST
post_tool = RequestsPostTool(
    requests_wrapper=requests_wrapper,
    allow_dangerous_requests=True
)

# Ejemplo de uso para crear un nuevo recurso
post_response = post_tool.invoke({
    "url": "https://jsonplaceholder.typicode.com/posts",
    "data": {
        "title": "Mi nuevo post",
        "body": "Contenido del post creado desde LangChain",
        "userId": 1
    }
})

print(post_response)

Manejo de headers y autenticación

El TextRequestsWrapper permite configurar headers personalizados:

# Configurar wrapper con headers personalizados
requests_wrapper = TextRequestsWrapper(
    headers={
        "User-Agent": "LangChain-App/1.0",
        "Content-Type": "application/json"
    }
)

# Para APIs que requieren autenticación
api_key = os.getenv("API_KEY")
authenticated_wrapper = TextRequestsWrapper(
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
)

# Crear herramientas con autenticación
auth_get_tool = RequestsGetTool(
    requests_wrapper=authenticated_wrapper,
    allow_dangerous_requests=True
)

Integración con múltiples herramientas HTTP

LangChain proporciona herramientas adicionales para operaciones HTTP completas:

from langchain_community.tools import RequestsPatchTool, RequestsDeleteTool

# Crear conjunto completo de herramientas HTTP
patch_tool = RequestsPatchTool(
    requests_wrapper=requests_wrapper,
    allow_dangerous_requests=True
)

delete_tool = RequestsDeleteTool(
    requests_wrapper=requests_wrapper,
    allow_dangerous_requests=True
)

# Lista de herramientas disponibles
http_tools = [get_tool, post_tool, patch_tool, delete_tool]

# Vincular todas las herramientas al modelo
llm_with_http_tools = llm.bind_tools(http_tools)

Integración con APIs RESTful externas

La integración con APIs RESTful representa uno de los casos de uso más valiosos de las herramientas HTTP, permitiendo que los modelos accedan a datos actualizados y servicios especializados en tiempo real.

Ejemplo práctico: consulta a API pública

from langchain_community.tools import RequestsGetTool
from langchain_community.utilities import TextRequestsWrapper
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain.messages import SystemMessage, HumanMessage

# Configurar herramienta
api_wrapper = TextRequestsWrapper(
    headers={"User-Agent": "LangChain-Bot/1.0"}
)

api_tool = RequestsGetTool(
    requests_wrapper=api_wrapper,
    allow_dangerous_requests=True
)

# Prompt especializado
api_prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content="""
    Eres un asistente que puede consultar APIs públicas.
    URLs disponibles:
    - Todos los productos: https://fakestoreapi.com/products
    - Producto específico: https://fakestoreapi.com/products/{id}
    - Categorías: https://fakestoreapi.com/products/categories
    
    Analiza los datos JSON y proporciona respuestas útiles.
    """),
    HumanMessage(content="{consulta}")
])

# Crear cadena
llm = ChatOpenAI(model="gpt-4o", temperature=0)
api_llm = llm.bind_tools([api_tool])
api_chain = api_prompt | api_llm

Manejo de errores y respuestas

# Configurar wrapper con límites
limited_wrapper = TextRequestsWrapper(
    headers={"User-Agent": "LangChain-Bot"}
)

robust_get_tool = RequestsGetTool(
    requests_wrapper=limited_wrapper,
    allow_dangerous_requests=True
)

# Ejemplo con manejo de errores
try:
    response = robust_get_tool.invoke({
        "url": "https://api.ejemplo.com/datos"
    })
    print(f"Respuesta exitosa: {response}")
except Exception as e:
    print(f"Error en la petición: {e}")

Consideraciones de seguridad

Al implementar integraciones con APIs externas en entornos de producción, sigue estas prácticas:

Gestión segura de credenciales:

import os

def load_api_config():
    config = {
        "api_key": os.getenv("API_KEY"),
        "oauth_token": os.getenv("OAUTH_TOKEN")
    }
    
    missing_keys = [k for k, v in config.items() if not v]
    if missing_keys:
        raise ValueError(f"Faltan variables de entorno: {missing_keys}")
    
    return config

Validación de URLs:

from urllib.parse import urlparse

def validate_api_url(url: str, allowed_domains: list) -> bool:
    """Validar que la URL pertenezca a dominios permitidos"""
    parsed = urlparse(url)
    return parsed.netloc in allowed_domains

# Lista de dominios permitidos
ALLOWED_DOMAINS = [
    "api.openweathermap.org",
    "fakestoreapi.com",
    "jsonplaceholder.typicode.com"
]

Wrapper seguro con validación:

class SecureRequestsWrapper(TextRequestsWrapper):
    def __init__(self, allowed_domains: list, **kwargs):
        super().__init__(**kwargs)
        self.allowed_domains = allowed_domains
    
    def get(self, url: str, **kwargs) -> str:
        if not validate_api_url(url, self.allowed_domains):
            raise ValueError(f"Dominio no permitido: {urlparse(url).netloc}")
        return super().get(url, **kwargs)

# Usar el wrapper seguro
secure_wrapper = SecureRequestsWrapper(
    allowed_domains=ALLOWED_DOMAINS,
    headers={"User-Agent": "LangChain-Secure/1.0"}
)

secure_tool = RequestsGetTool(
    requests_wrapper=secure_wrapper,
    allow_dangerous_requests=True
)

Esta aproximación de integración con APIs RESTful permite crear sistemas LangChain robustos y seguros que pueden interactuar con prácticamente cualquier servicio web moderno.