Construyendo Strands Agents con Pocas Líneas de Código: Tools Personalizadas e Integración MCP

🔗 Repositorio en GitHub

Descubre cómo crear agentes que pueden interactuar con tu entorno de desarrollo usando herramientas personalizadas y el Protocolo de Contexto de Modelos (MCP) con Strands Agents.

En esta publicación, aprenderás cómo empoderar agentes con herramientas que les permiten interactuar con sistemas externos, acceder a datos, y cómo implementar el Protocolo de Contexto de Modelos (MCP) como un mecanismo para extender las capacidades de los agentes.

Comencemos a Construir

Antes de sumergirnos en la implementación, configuremos las dependencias necesarias y la configuración.

Prerrequisitos

1. Clona el repositorio:

git clone https://github.com/elizabethfuentes12/strands-agent-samples
cd notebook

1. Crea y activa un entorno virtual:

python -m venv .venv
source .venv/bin/activate  # En Windows: .venv\Scripts\activate

1. Instala las dependencias requeridas:

pip install -r requirements.txt

🌦️☀️ Construyendo un Agente del Clima

Los agentes Strands ofrecen un Paquete de Herramientas de Ejemplo. También puedes crear herramientas personalizadas similares a la implementación MCP, pero sin la necesidad de ejecutar un servidor dedicado.

Para crear el agente del clima, usamos la herramienta http_request. Esta herramienta conecta los agentes Strands con servicios web externos y APIs, creando un puente entre la IA conversacional y las fuentes de datos. La herramienta soporta múltiples métodos HTTP (GET, POST, PUT, DELETE), maneja la codificación de URL y el análisis de respuestas, y devuelve datos estructurados de fuentes web.

from strands import Agent
from strands_tools import http_request
from strands.models.anthropic import AnthropicModel
import os

# Define un prompt del sistema enfocado en el clima
WEATHER_SYSTEM_PROMPT = """Eres un asistente meteorológico con capacidades HTTP. Puedes:

1. Hacer solicitudes HTTP a la API del Servicio Nacional del Clima
2. Procesar y mostrar datos de pronósticos meteorológicos
3. Proporcionar información meteorológica para ubicaciones en Estados Unidos

Al obtener información meteorológica:
1. Primero obtén las coordenadas o información de cuadrícula usando https://api.weather.gov/points/{latitude},{longitude} o https://api.weather.gov/points/{zipcode}
2. Luego usa la URL de pronóstico devuelta para obtener el pronóstico real

Al mostrar respuestas:
- Formatea los datos meteorológicos de manera legible para humanos
- Destaca información importante como temperatura, precipitación y alertas
- Maneja los errores apropiadamente
- Convierte términos técnicos a lenguaje amigable para el usuario

Siempre explica las condiciones meteorológicas claramente y proporciona contexto para el pronóstico.
"""

model = AnthropicModel(
    client_args={
         "api_key": api_key #os.getenv("api_key") #Aquí tus credenciales
    },
    # **model_config
    max_tokens=1028,
    model_id="claude-sonnet-4-20250514",
    params={
        "temperature": 0.7,
    }
)

# Crea un agente con capacidades HTTP
weather_agent = Agent(
    model = model,
    system_prompt=WEATHER_SYSTEM_PROMPT,
    tools=[http_request],  # Habilita explícitamente la herramienta http_request
)

✅ Prueba el Agente del Clima

response = weather_agent("¿Cómo está el clima en Seattle?")

🌦️☀️ Agente del Clima con una Herramienta Personalizada (Python Tool)

Una de las fortalezas del framework Strands es la habilidad de crear herramientas personalizadas que extienden las capacidades del agente.

from strands import Agent
from strands_tools import http_request
from strands.models.anthropic import AnthropicModel
from strands.tools import tool
from typing import Dict, Any

# Define una función para convertir Fahrenheit a Celsius
@tool
def fahrenheit_to_celsius(params: Dict[str, Any]) -> Dict[str, Any]:
    """
    Convierte temperatura de Fahrenheit a Celsius.

    Args:
        params: Un diccionario que contiene:
            - fahrenheit: La temperatura en Fahrenheit a convertir

    Returns:
        Un diccionario que contiene:
            - celsius: La temperatura en Celsius
            - original_fahrenheit: El valor original en Fahrenheit
    """
    try:
        fahrenheit = float(params.get("fahrenheit"))
        celsius = (fahrenheit - 32) * 5/9
        return {
            "celsius": round(celsius, 2),
            "original_fahrenheit": fahrenheit
        }
    except (TypeError, ValueError):
        return {
            "error": "Entrada inválida. Por favor proporciona un número válido para fahrenheit."
        }

# Define un prompt del sistema enfocado en el clima
WEATHER_SYSTEM_PROMPT_C_TOOL = """Eres un asistente meteorológico con capacidades HTTP. Puedes:

1. Hacer solicitudes HTTP a la API del Servicio Nacional del Clima
2. Procesar y mostrar datos de pronósticos meteorológicos
3. Proporcionar información meteorológica para ubicaciones en Estados Unidos
4. Usar fahrenheit_to_celsius para convertir temperaturas entre Fahrenheit y Celsius

Al obtener información meteorológica:
1. Primero obtén las coordenadas o información de cuadrícula usando https://api.weather.gov/points/{latitude},{longitude} o https://api.weather.gov/points/{zipcode}
2. Luego usa la URL de pronóstico devuelta para obtener el pronóstico real

Al mostrar respuestas:
- Formatea los datos meteorológicos de manera legible para humanos
- Destaca información importante como temperatura, precipitación y alertas
- Maneja los errores apropiadamente
- Convierte términos técnicos a lenguaje amigable para el usuario

Siempre explica las condiciones meteorológicas claramente y proporciona contexto para el pronóstico.
"""

model = AnthropicModel(
    client_args={
        "api_key": api_key, #Aquí tus credenciales
    },
    # **model_config
    max_tokens=1028,
    model_id="claude-sonnet-4-20250514",
    params={
        "temperature": 0.7,
    }
)

# Crea un agente con capacidades HTTP
weather_agent_c_tool = Agent(
    model = model,
    system_prompt=WEATHER_SYSTEM_PROMPT_C_TOOL,
    tools=[http_request,fahrenheit_to_celsius],  # Habilita explícitamente la herramienta http_request
)

✅ Prueba el Agente del Clima

response_c_tool = weather_agent_c_tool("¿Cómo está el clima en Seattle? Por favor dame la respuesta en grados Celsius")

Creemos un Servidor MCP de Calculadora

En esta sección, haremos un recorrido de bloques de código seleccionados que se han usado para construir mcp_calculator.py para crear un servidor MCP simple que proporciona funcionalidad limitada de calculadora.

El Protocolo de Contexto de Modelos (MCP)

El Protocolo de Contexto de Modelos (MCP) es un protocolo abierto que estandariza la forma de exponer y consumir herramientas a través de diferentes sistemas. Este enfoque es ideal para crear colecciones de herramientas reutilizables que pueden ser compartidas entre múltiples agentes o aplicaciones.

Puedes crear tu propio servidor MCP para extender las capacidades del agente.

Componentes de la Arquitectura MCP

• Cliente MCP: Integrado en el Framework de Agentes Strands
• Servidor MCP: Servicio independiente que aloja herramientas
• Herramientas MCP: Funcionalidades específicas (calculadora, clima, etc.)

✅ Crear el Servidor MCP

from mcp.server import FastMCP

mcp = FastMCP("Calculator Server")

@mcp.tool(description="Suma dos números")
def add(x: int, y: int) -> int:
    """Suma dos números y devuelve el resultado."""
    return x + y

# Define una herramienta de resta
@mcp.tool(description="Resta un número de otro")
def subtract(x: int, y: int) -> int:
    """Resta y de x y devuelve el resultado.

    Args:
        x: Número del cual restar
        y: Número a restar

    Returns:
        La diferencia (x - y)
    """
    return x - y

# Define una herramienta de multiplicación
@mcp.tool(description="Multiplica dos números")
def multiply(x: int, y: int) -> int:
    """Multiplica dos números y devuelve el resultado.

    Args:
        x: Primer número
        y: Segundo número

    Returns:
        El producto de x y y
    """
    return x * y

# Define una herramienta de división
@mcp.tool(description="Divide un número entre otro")
def divide(x: float, y: float) -> float:
    """Divide x entre y y devuelve el resultado.

    Args:
        x: Numerador
        y: Denominador (no debe ser cero)

    Returns:
        El cociente (x / y)

    Raises:
        ValueError: Si y es cero
    """
    if y == 0:
        raise ValueError("No se puede dividir entre cero")
    return x / y

mcp_calculator.py usa HTTP Streamable como Conexión del Servidor MCP:

mcp.run(transport="streamable-http")

✅ Conectando el Servidor al Agente Strands

El siguiente código muestra cómo crear un agente Strands y conectarlo a un servidor MCP:

from mcp.client.streamable_http import streamablehttp_client
from strands import Agent
from strands.tools.mcp.mcp_client import MCPClient
from strands.models.anthropic import AnthropicModel

model = AnthropicModel(
    client_args={
        "api_key": "<KEY>", #Aquí tus credenciales
    },
    # **model_config
    max_tokens=1028,
    model_id="claude-sonnet-4-20250514",
    params={
        "temperature": 0.7,
    }
)

# Crea un prompt del sistema que explique las capacidades de la calculadora
system_prompt = """
Eres un asistente de calculadora útil que puede realizar operaciones aritméticas básicas.
Tienes acceso a las siguientes herramientas de calculadora:
- add: Suma dos números
- subtract: Resta un número de otro
- multiply: Multiplica dos números
- divide: Divide un número entre otro

Cuando se te pida realizar cálculos, usa la herramienta apropiada en lugar de calcular el resultado tú mismo.
Explica el cálculo y muestra el resultado claramente.
"""

def create_streamable_http_transport():
   return streamablehttp_client("http://localhost:8000/mcp/")

streamable_http_mcp_client = MCPClient(create_streamable_http_transport)

# Usa el servidor MCP en un gestor de contexto
with streamable_http_mcp_client:
    # Obtén las herramientas del servidor MCP
    tools = streamable_http_mcp_client.list_tools_sync()

    # Crea un agente con las herramientas MCP
    agent = Agent(model=model,system_prompt=system_prompt,tools=tools)

✅ Prueba el Agente Calculadora

Ve a la terminal y ejecuta la aplicación:

python3 mcp_calulator.py

Mejores Prácticas

Al construir agentes con MCP y herramientas personalizadas, considera estas mejores prácticas:

• Seguridad Primero: Solo otorga acceso a directorios y recursos necesarios
• Manejo de Errores: Implementa manejo robusto de errores en herramientas personalizadas
• Gestión de Recursos: Monitorea el uso de recursos al procesar archivos grandes
• Composición de Herramientas: Diseña herramientas para que funcionen bien juntas
• Documentación: Proporciona descripciones claras para todas las herramientas personalizadas

¿Qué Sigue?

¡Esto no es todo lo que tengo para ti! Esto es parte de mi serie continua explorando las capacidades de Strands Agents, donde te muestro cómo construir aplicaciones poderosas con solo unas pocas líneas de código.

En próximas publicaciones, demostraré:

• Strands Agents y Comunicación de Agente a Agente (A2A)
• 🔍📊 Observabilidad con LangFuse y Evaluación con RAGAS

¡Mantente atento para más implementaciones de Strands Agent!

Recursos

• Repositorio de GitHub: Strands Agent Samples
• Notebook Completo: Strands_MCP_AND_Tools.ipynb
• Documentación: Strands Agents Official Docs

---

¡Gracias por leer!

Gracias!

🇻🇪🇨🇱 Dev.to | LinkedIn | GitHub | Twitter | Instagram | YouTube

AWS Developer Advocate