Connect Your Strands Agent to 18 MCP Servers in 5 Minutes

March 19, 2026 · Tutorial · 10 min read

---

Your Strands agent is smart. It can reason, plan, and hold multi-turn conversations. But without tools, it's just a chatbot with good grammar.

The Model Context Protocol (MCP) solves this by giving agents a standard way to connect to external tools — web search, file management, APIs, databases, and more. The problem? Building and hosting MCP servers is a pain. You need infrastructure, error handling, auth, and ongoing maintenance.

What if you could skip all that and just connect to a library of pre-built, hosted MCP servers?

That's what Universal API gives you. In this tutorial, I'll show you two ways to connect your Strands agent to UAPI's 18+ MCP servers — and have a fully-equipped agent running in under 5 minutes.

What's Available

Universal API hosts a growing catalog of MCP servers, each providing tools your agent can use. Here's a sample:

MCP Server	What It Does	Example Tools
universalapi-full	Full platform management	Create agents, manage MCP servers, search resources, upload files
doc-hound	Web search + scraping	search_web, scrape_and_extract
serpapi	Google & Reddit search	google_search, reddit_search
google-suite	Gmail, Calendar, Drive	send_email, list_events, search_drive
aws-textract	Document OCR	analyze_document, extract_tables
aws-mcp-proxy	Any AWS service	invoke_aws_service

Every server runs on managed infrastructure — no Docker containers, no Lambda functions, no servers to maintain. You just connect and use the tools.

Prerequisites

Before we start, you'll need:

1. Python 3.10+ with the Strands SDK installed
2. A Universal API account — sign up free (100 credits included)
3. A Bearer token — create one on the Credentials page

Install the Strands SDK if you haven't already:

pip install strands-agents strands-agents-tools

Method 1: Connect at Agent Creation (Recommended)

This is the standard approach for production agents. You wire up MCP connections when you create the agent, and the tools are available for every conversation.

import os
from strands import Agent
from strands.models.bedrock import BedrockModel
from strands.tools.mcp import MCPClient
from strands.tools.mcp.mcp_client import StreamableHTTPTransport

# Your UAPI Bearer token
UAPI_TOKEN = os.environ.get("UAPI_TOKEN", "uapi_ut_your_token_here")

# Set up the model
model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1"
)

# Connect to Doc Hound (web search + scraping)
dochound = MCPClient(
    transport=StreamableHTTPTransport(
        url="https://mcp.api.universalapi.co/mcp/s/snowtimber/doc-hound",
        headers={"Authorization": f"Bearer {UAPI_TOKEN}"}
    )
)

# Connect to SerpAPI (Google search)
serpapi = MCPClient(
    transport=StreamableHTTPTransport(
        url="https://mcp.api.universalapi.co/mcp/s/snowtimber/serpapi",
        headers={"Authorization": f"Bearer {UAPI_TOKEN}"}
    )
)

# Create the agent with MCP tools
agent = Agent(
    model=model,
    tools=[dochound, serpapi],
    system_prompt="You are a research assistant with web search capabilities."
)

# Use it
response = agent("What are the latest developments in MCP servers?")
print(response)

That's it. Your agent now has search_web, scrape_and_extract, google_search, and reddit_search — all from two lines of MCP configuration.

Using Slug-Based URLs

Notice the URL pattern: https://mcp.api.universalapi.co/mcp/s/{owner}/{slug}

Every UAPI MCP server has a human-readable slug URL. You can also use the server ID directly:

https://mcp.api.universalapi.co/mcp/{serverId}

Browse available servers at universalapi.co/mcp-servers to find slugs and IDs.

Context Manager Pattern

For proper cleanup, use the context manager pattern:

with dochound, serpapi:
    agent = Agent(
        model=model,
        tools=[dochound, serpapi],
        system_prompt="You are a research assistant."
    )
    response = agent("Search the web for MCP server best practices")
    print(response)
# Connections are automatically cleaned up

Method 2: Dynamic Runtime Connections

Sometimes you don't know which MCP servers you'll need until the conversation is underway. The mcp_client tool from strands-agents-tools lets your agent connect to MCP servers during a conversation.

from strands import Agent
from strands.models.bedrock import BedrockModel
from strands_tools import mcp_client

model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1"
)

agent = Agent(
    model=model,
    tools=[mcp_client],
    system_prompt="""You are a research assistant. You can dynamically connect 
    to MCP servers on Universal API to gain new capabilities.
    
    Available UAPI MCP servers (connect via streamable_http):
    - Doc Hound (web search): https://mcp.api.universalapi.co/mcp/s/snowtimber/doc-hound
    - SerpAPI (Google search): https://mcp.api.universalapi.co/mcp/s/snowtimber/serpapi
    - Google Suite: https://mcp.api.universalapi.co/mcp/s/snowtimber/google-suite
    
    When you need a capability, connect to the appropriate server first,
    then use its tools. Always include the Authorization header with the 
    user's Bearer token."""
)

# The agent will dynamically connect to servers as needed
response = agent("Search Google for 'Strands agents MCP tutorial' and summarize the top results")

With this approach, the agent decides at runtime which servers to connect to. It will:

1. Call mcp_client(action="connect", transport="streamable_http", server_url="...", headers={...})
2. Call mcp_client(action="list_tools", connection_id="...") to discover available tools
3. Call mcp_client(action="call_tool", connection_id="...", tool_name="search_web", arguments={...})

This is powerful for exploratory agents that need flexibility, but Method 1 is simpler and more reliable for production use.

Full Example: Research Agent with Web + Knowledge

Here's a complete, production-ready agent that combines web search with your private document storage:

import os
from strands import Agent
from strands.models.bedrock import BedrockModel
from strands.tools.mcp import MCPClient
from strands.tools.mcp.mcp_client import StreamableHTTPTransport

UAPI_TOKEN = os.environ["UAPI_TOKEN"]

model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1"
)

# Universal API platform tools (Knowledge search, resource management)
uapi = MCPClient(
    transport=StreamableHTTPTransport(
        url="https://mcp.api.universalapi.co/mcp/s/snowtimber/universalapi-full",
        headers={"Authorization": f"Bearer {UAPI_TOKEN}"}
    )
)

# Web search + page scraping
dochound = MCPClient(
    transport=StreamableHTTPTransport(
        url="https://mcp.api.universalapi.co/mcp/s/snowtimber/doc-hound",
        headers={"Authorization": f"Bearer {UAPI_TOKEN}"}
    )
)

system_prompt = """You are a research assistant with two superpowers:

1. **Knowledge Search** — Search the user's uploaded documents (PDFs, reports, 
   contracts) using the search_knowledge tool. Always search here first.

2. **Web Search** — Search the internet and scrape web pages for additional 
   context using search_web and scrape_and_extract.

When answering questions:
- Search the user's Knowledge first for relevant document sections
- Use web search for external context, comparisons, or current information
- Always cite your sources — mention which document or URL the info came from
- If you're unsure, say so rather than guessing
"""

with uapi, dochound:
    agent = Agent(
        model=model,
        tools=[uapi, dochound],
        system_prompt=system_prompt
    )
    
    # Multi-turn conversation
    agent("What do my uploaded contracts say about termination clauses?")
    agent("Now search the web for standard commercial lease termination terms")
    agent("How do my contracts compare to industry standard?")

This agent can:

• Search across your uploaded documents using semantic search (not just keyword matching)
• Search Google and scrape web pages for current information
• Combine private and public knowledge to give you comprehensive answers

How Authentication Works

UAPI MCP servers use Bearer token authentication. When you pass your token in the Authorization header, the server knows who you are and can:

• Access your Knowledge storage — search your uploaded documents
• Use your API keys — if you've stored third-party keys (like SerpAPI), they're automatically injected
• Track usage — each tool call costs credits, deducted from your account

# Your token goes in the headers
headers = {"Authorization": f"Bearer {UAPI_TOKEN}"}

You can create multiple tokens with different credit limits for different use cases:

# Create a token with a 1000-credit limit
curl -X POST https://api.universalapi.co/access-tokens/create \
  -H "Authorization: Bearer YOUR_MAIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tokenName": "research-agent", "creditLimit": 1000}'

What It Costs

On Universal API's free tier (100 credits):

Operation	Cost
Web search (Doc Hound)	~1 credit per search
Page scraping	~1 credit per page
Knowledge search	~1 credit per query
Google search (SerpAPI)	~1 credit per search

Most agent conversations use 5-15 credits total. The free tier gets you started, and the Starter plan ($29/month, 30,000 credits) covers thousands of research queries.

Connecting from Claude Desktop or Cline

Not using Strands? These same MCP servers work with any MCP client. Here's how to connect from popular AI tools:

Cline (VS Code):

{
  "doc-hound": {
    "type": "streamableHttp",
    "url": "https://mcp.api.universalapi.co/mcp/s/snowtimber/doc-hound",
    "headers": {
      "Authorization": "Bearer uapi_ut_your_token_here"
    }
  }
}

Claude Desktop (via mcp-remote):

{
  "mcpServers": {
    "doc-hound": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://mcp.api.universalapi.co/mcp/s/snowtimber/doc-hound",
        "--header",
        "Authorization: Bearer uapi_ut_your_token_here"
      ]
    }
  }
}

What's Next

This tutorial covered the basics — connecting to existing MCP servers. But Universal API also lets you:

• Build your own MCP servers — Write Node.js tools and deploy them with a single API call
• Create hosted agents — Deploy Strands agents that others can chat with via API
• Store and search documents — Upload files to Knowledge storage for semantic search
• Publish to the marketplace — Share your MCP servers and agents with the community

Try It Yourself

1. Sign up for Universal API — free, 100 credits included
2. Create a Bearer token on the Credentials page
3. Copy the code above and replace uapi_ut_your_token_here with your token
4. Run it — your agent now has web search, document analysis, and more

The whole setup takes about 5 minutes. The tools your agent gains? That's an entire ecosystem.

---

Have questions or want to share what you built? Find us on GitHub. Browse all available MCP servers at universalapi.co/mcp-servers.