Cree agentes de IA con RapidAPI para datos en tiempo existente

La creación de agentes se ha vuelto más comprensible que nunca, pero ¿alguna vez has pensado: cómo podemos hacerlos más poderosos de lo que ya son? Recientemente pensé en una posible forma: ¿y si tuvieran información en tiempo existente sobre categorías específicas como finanzas y películas? Eso sería verdaderamente magnífico, ¿verdad? Mientras exploraba esta opción, descubrí que RapidAPI es un centro de API que puede dar llegada a los agentes de IA a información en tiempo existente con una simple emplazamiento API. Luego decidí crear algunos agentes que puedan utilizar estas API para crear mejores agentes de entretenimiento de roles.

En este artículo, comparto todo el proceso para que puedas seguirlo fácilmente y replicar los resultados para tu propio uso. Comencemos con alguna información básica:

¿Qué es RapidAPI?

RapidAPI es en existencia el nombre más antiguo y recientemente se convirtió en Nokia API Hub luego de la adquisición. Tiene un catálogo de API donde podemos usar o difundir API. Cubre categorías variadas desde CiberseguridadPelículas, Comunicación y más. Puede explore más sobre RapidAPI aquí.

¿Cómo utilizar las API de RapidAPI?

1. Primero inicie sesión/regístrese en RapidAPI aquí

2. Ir a un página de autorización del desarrollador y cree una autorización de tipo ‘RapidAPI’ haciendo clic en ‘Amplificar autorización’ en la parte superior derecha.

3. Regrese a la página de inicio para descubrir las API y haga clic en la API que desee. Por ejemplo, yo hizo clic en una API de parte sobre criptomonedas aquí.

4. Verá una página como esta; encima, la esencia API ya está presente en el código de prueba. Solo asegúrese de que el objetivo esté establecido en ‘pitón‘:

5. Ahora haga clic en ‘Suscribirse para probar’ en la parte superior derecha y seleccione el nivel de balde por ahora. Y luego haga clic en suscribirse luego de hacer clic en ‘Iniciar plan de balde’.

6. Ahora puede usar el tallo de punto final de prueba en la parte superior derecha y se ejecutará el código de prueba y podrá obtener la respuesta.

Nota: La mayoría de las API tienen un nivel de balde espléndido y se pueden utilizar hasta los límites mensuales mencionados.

Hacer agentes integrados con RapidAPI

En esta sección crearemos agentes usando la función ‘create_agent’ de langchain.agents y los agentes funcionarán con Hendido AIconcretamente el ‘gpt-5-mini’. Siéntase suelto de verificar con diferentes modelos, proveedores de modelos o marcos de agentes.

Requisito previo

Para evitar repeticiones, usaremos el mismo conjunto de importaciones e inicializaremos las API para usarlo con múltiples agentes. Y asegúrese de suscribirse a las API en los enlaces si desea realizar la prueba conmigo. Incluso usaré Google Colab para la demostración.

Suscríbete a estas API

Configure su cuaderno de Google Colab

Agregue su API OpenAI y RapidAPI como ‘OPENAI_API_KEY’ y ‘RAPIDAPI_KEY’ en la sección de secretos de la izquierda y no olvide activar el llegada al cuaderno.

Instalaciones

!pip install langchain langchain_core langchain_openai -q 

Importaciones

from google.colab import userdata 
import os 
import http.client 
import json 
from langchain_core.tools import tool 
from langchain_openai import ChatOpenAI 
from langchain.agents import create_agent

Claves API

os.environ('OPENAI_API_KEY') = userdata.get('OPENAI_API_KEY') 
RAPIDAPI_KEY = userdata.get('RAPIDAPI_KEY') 

Construyendo un agente de parte

@tool
def search_news(query: str, limit: int = 10) -> str:
    """Search for real-time news articles based on a query. Returns latest news articles."""
    conn = http.client.HTTPSConnection("real-time-news-data.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "real-time-news-data.p.rapidapi.com",
    }

    conn.request(
        "GET",
        f"/search?query={query}&limit={limit}&time_published=anytime&country=US&lang=en",
        headers=headers,
    )

    res = conn.getresponse()
    data = res.read()
    result = json.loads(data.decode("utf-8"))

    return json.dumps(result, indent=2)

news_agent = create_agent(
    ChatOpenAI(temperature=0, model="gpt-5-mini"),
    tools=(search_news),
)

Tenga en cuenta que estamos utilizando la API proporcionada por RapidAPI como utensilio y pasando la utensilio al agente. El Agente recibirá ayuda de la utensilio siempre que considere necesaria una emplazamiento a la utensilio.

# Test the agent 
result = news_agent.invoke({ 
 "messages": ({"role": "user", "content": "Search for latest news about Messi"}) 

}) 
print(result("messages")(-1).content)

Resultado

¡Excelente! Hemos creado nuestro primer agente y tiene buena pinta. Puede verificar con nuevas indicaciones si lo desea.

Nota: Nuestro agente trabaja principalmente cuando se le pregunta poco usando solo una palabra (ejemplo: “Deportes”, “Bosque”, etc.). Esto se debe a que la utensilio acepta solo una condena y no una oración; para solucionar este problema podemos configurar el indicador del sistema de nuestro agente.

Agente de Bolsa

Creemos un agente de stock que use API de Yahoo para obtener los detalles de las acciones utilizando un símbolo de cotización de cualquier bono en particular.

Código

@tool
def get_stock_history(symbol: str, interval: str = "1m", limit: int = 640) -> str:
    """Get historical stock price data for a symbol."""
    conn = http.client.HTTPSConnection("yahoo-finance15.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "yahoo-finance15.p.rapidapi.com",
    }

    path = (
        f"/api/v2/markets/stock/history?"
        f"symbol={symbol}&interval={interval}&limit={limit}"
    )

    conn.request("GET", path, headers=headers)
    res = conn.getresponse()
    data = res.read()
    result = json.loads(data.decode("utf-8"))

    return json.dumps(result, indent=2)


stock_agent = create_agent(
    ChatOpenAI(temperature=0, model="gpt-5-mini"),
    tools=(get_stock_history),
)

# Example call
result = stock_agent.invoke(
    {"messages": ({"role": "user", "content": "Get the last intraday price history for AAPL"})}
)

print(result("messages")(-1).content)

Resultado

Perspicaz, recuperamos con éxito el resultado de AAPL (Apple Inc.) y la información es completamente en tiempo existente.

Agente de Propiedades

El objetivo aquí es crear un agente usando una API que busque propiedades en liquidación/locación, la que estamos usando desde Zoopla rebusca propiedades específicamente en el Reino Unido.

Código

@tool
def search_properties(
    location_value: str,
    location_identifier: str = "city",
    page: int = 1,
) -> str:
    """
    Search for residential properties.

    Args:
        location_value: The name of the location
            (e.g., 'London', 'Manchester', 'E1 6AN').
        location_identifier: The category of the location.
            - Use 'city' for major cities (default).
            - Use 'postal_code' if the user provides a postcode (e.g., 'W1').
            - Use 'area' for smaller neighborhoods.
    """
    # URL encoding to prevent InvalidURL errors
    safe_val = location_value.replace(" ", "%20").replace(",", "%2C")
    safe_id = location_identifier.replace(" ", "%20")

    conn = http.client.HTTPSConnection("zoopla.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "zoopla.p.rapidapi.com",
    }

    path = (
        f"/properties/v2/list?locationValue={safe_val}"
        f"&locationIdentifier={safe_id}"
        f"&category=residential&furnishedState=Any"
        f"&sortOrder=newest_listings&page={page}"
    )

    conn.request("GET", path, headers=headers)
    res = conn.getresponse()
    data = res.read()
    result = json.loads(data.decode("utf-8"))

    return json.dumps(result, indent=2)


property_agent = create_agent(
    ChatOpenAI(temperature=0, model="gpt-5-mini"),
    tools=(search_properties),
    system_prompt=(
        "You are a real-estate expert. When a user asks for a location, "
        "infer the 'location_identifier' yourself, usually 'city' or "
        "'postal_code'. Do not ask the user for technical identifiers; "
        "call the tool immediately."
    ),
)

result = property_agent.invoke(
    {"messages": ({"role": "user", "content": "Search for properties in London, England"})}
)

print(result("messages")(-1).content)

Resultado

Recibimos las propiedades reales como resultado, pero se han desdibujado por razones obvias.

Agente recomendador de películas

Este agente tendrá llegada a las API mejor y peor calificadas de IMDB como herramientas y configuraremos el mensaje del sistema para designar qué utensilio usar según el mensaje.

@tool
def get_top_rated_movies() -> str:
    """
    Fetch the list of top-rated English movies on IMDb.

    Use this when the user wants a recommendation or a "good" movie.
    """
    conn = http.client.HTTPSConnection("imdb236.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "imdb236.p.rapidapi.com",
    }

    conn.request("GET", "/api/imdb/top-rated-english-movies", headers=headers)
    res = conn.getresponse()

    # Decode and return raw JSON for the agent to process
    return res.read().decode("utf-8")


@tool
def get_lowest_rated_movies() -> str:
    """
    Fetch the list of lowest-rated movies on IMDb.

    Use this when the user asks for "bad" movies or movies to avoid.
    """
    conn = http.client.HTTPSConnection("imdb236.p.rapidapi.com")

    headers = {
        "x-rapidapi-key": RAPIDAPI_KEY,
        "x-rapidapi-host": "imdb236.p.rapidapi.com",
    }

    conn.request("GET", "/api/imdb/lowest-rated-movies", headers=headers)
    res = conn.getresponse()

    return res.read().decode("utf-8")


movie_agent = create_agent(
    ChatOpenAI(temperature=0, model="gpt-5-mini"),
    tools=(get_top_rated_movies, get_lowest_rated_movies),
    system_prompt=(
        "You are an expert movie critic. Your goal is to help users find movies "
        "based on quality. If a user asks for something 'good', 'recommended', "
        "or 'classic', call get_top_rated_movies. If a user asks for something "
        "'bad', 'terrible', or 'lowest rated', call get_lowest_rated_movies. "
        "Both tools require no parameters. Summarize the results in a friendly "
        "way in a single sentence."
    ),
)

# Example usage
result = movie_agent.invoke(
    {
        "messages": (
            {
                "role": "user",
                "content": "I'm in the mood for a really terrible movie, what's the worst out there?",
            }
        )
    }
)

print(result("messages")(-1).content)

Resultado

If you want truly awful, IMDb’s lowest-rated picks include Daniel der
 Zauberer (Daniel the Wizard) and Smolensk — both hovering around a 1.2
 promedio rating and perfect if you’re after a 
“so-bad-it’s-fascinating” watch. 

¡Excelente! Hemos creado con éxito un agente que puede penetrar a múltiples herramientas y puede sugerir películas tanto con las mejores calificaciones como con las peores calificaciones.

Conclusión

Al integrar API en tiempo existente con agentes, podemos ir más allá de las respuestas estáticas y crear sistemas que parezcan verdaderamente inteligentes. RapidAPI hace que esta integración sea simple y escalable entre dominios. Incluso es importante que elijamos las herramientas adecuadas y además ajustemos el agente para que funcione en conformidad con la utensilio. Por ejemplo, muchas API pueden dar un error si hay comillas simples o espacios en el argumento. Incluso ofertas RapidAPI Soporte MCP en sus API, que se pueden explorar en los esfuerzos continuos para crear mejores agentes.

Preguntas frecuentes