Strands Agents MCP Server
OfficialThis MCP server provides curated documentation access to your GenAI tools via llms.txt files, enabling AI coding assistants to find pages by title and retrieve their contents.
Features
Document Search: Weighted TF-IDF ranking over document titles, extended to page content once a page is hydrated (fetched), so body terms become searchable
Section-Based Browsing: Browse document structure via table of contents, then fetch only the section you need - more token-efficient than retrieving full pages
Curated Content: Indexes documentation from llms.txt files with clean, human-readable titles
On-Demand Fetching: Lazy-loads full document content only when needed for optimal performance
Snippet Generation: Hydrates the top-ranked pages to provide contextual previews
Real URL Support: Works with actual HTTPS URLs while maintaining backward compatibility
Tool behavior
search_docs(query, k)ranks by document title and by page content once a page has been hydrated. Both title-like keywords and body terms work; callfetch_docto inspect a result's contents.Search scores are unbounded weighted TF-IDF values. They are useful only for ordering results from the same query; they are not probabilities and should not be compared across queries.
search_docsreturns an empty list when no document matches. If a matched page cannot be fetched for its snippet, the result still includes the URL and title.fetch_docreturns{"error": "...", "url": "..."}for unsupported URLs and failed page fetches. For sectioned documents, unknown section IDs also return an error;sectionis ignored when the full document is returned automatically.
Related MCP server: mcp-a2a-documentation
Configuration
STRANDS_MCP_PREFETCH_ALL: when set to a truthy value (1,true,yes), the server prefetches and indexes all pages in the background at startup, so body-term search works immediately instead of only after a page has been hydrated by a prior query. Defaults to off. Prefetch is best-effort and eventually consistent: results may be title-only until background hydration completes.
Prerequisites
The usage methods below require uv to be installed on your system. You can install it by following the official installation instructions.
Installation
You can use the Strands Agents MCP server with 40+ applications that support MCP servers, including Amazon Q Developer CLI, Anthropic Claude Code, Cline, and Cursor.
Get started quickly with one-click installation buttons for popular MCP clients. Click the buttons below to install servers directly in your IDE:
Kiro example
See the Kiro documentation for instructions on managing MCP configuration.
In ~/.kiro/settings/mcp.json:
{
"mcpServers": {
"strands-agents": {
"command": "uvx",
"args": ["strands-agents-mcp-server"],
"env": {
"FASTMCP_LOG_LEVEL": "INFO"
},
"disabled": false,
"autoApprove": ["search_docs", "fetch_doc"]
}
}
}Q Developer CLI example
See the Q Developer CLI documentation for instructions on managing MCP configuration.
In ~/.aws/amazonq/mcp.json:
{
"mcpServers": {
"strands-agents": {
"command": "uvx",
"args": ["strands-agents-mcp-server"],
"env": {
"FASTMCP_LOG_LEVEL": "INFO"
},
"disabled": false,
"autoApprove": ["search_docs", "fetch_doc"]
}
}
}Claude Code example
See the Claude Code documentation for instructions on managing MCP servers.
claude mcp add strands uvx strands-agents-mcp-serverCline example
See the Cline documentation for instructions on managing MCP configuration.
Provide Cline with the following information:
I want to add the MCP server for Strands Agents.
Here's the GitHub link: @https://github.com/strands-agents/harness-sdk/tree/main/strands-mcp
Can you add it?"Cursor example
See the Cursor documentation for instructions on managing MCP configuration.
In ~/.cursor/mcp.json:
{
"mcpServers": {
"strands-agents": {
"command": "uvx",
"args": ["strands-agents-mcp-server"],
"env": {
"FASTMCP_LOG_LEVEL": "INFO"
},
"disabled": false,
"autoApprove": ["search_docs", "fetch_doc"]
}
}
}VS Code example
See the VS Code documentation for instructions on managing MCP configuration.
In your mcp.json file:
{
"servers": {
"strands-agents": {
"command": "uvx",
"args": ["strands-agents-mcp-server"]
}
}
}Quick Testing
You can quickly test the MCP server using the MCP Inspector:
# For published package
npx @modelcontextprotocol/inspector uvx strands-agents-mcp-server
# For local development
npx @modelcontextprotocol/inspector python -m strands_mcp_serverNote: This requires npx to be installed on your system. It comes bundled with Node.js.
The Inspector is also useful for troubleshooting MCP server issues as it provides detailed connection and protocol information. For an in-depth guide, have a look at the MCP Inspector documentation.
Getting Started
Install prerequisites:
Install uv following the official installation instructions
Make sure you have Node.js installed for npx commands
Configure your MCP client:
Choose your preferred MCP client from the installation examples above
Add the Strands Agents MCP server configuration to your client
Test the connection:
# For published package npx @modelcontextprotocol/inspector uvx strands-agents-mcp-server # For local development npx @modelcontextprotocol/inspector python -m strands_mcp_serverStart using the documentation tools:
search_docs- Find relevant documentation with intelligent rankingfetch_doc- Browse a page's structure and preamble, then read individual sectionsThe server automatically indexes curated content from llms.txt files
Server Development
git clone https://github.com/strands-agents/harness-sdk.git
cd harness-sdk/strands-mcp
python3 -m venv venv
source venv/bin/activate
pip3 install -e ".[dev]"
npx @modelcontextprotocol/inspector python -m strands_mcp_serverRunning Tests
# Unit tests (fast, no network access required)
pytest tests/
# Integration tests (requires network access to strandsagents.com)
pytest tests_integ/ -v
# All tests
pytest tests/ tests_integ/ -vTo skip integration tests (e.g., in CI environments without network access):
SKIP_INTEG_TESTS=1 pytest tests_integ/Contributing ❤️
We welcome contributions! See our Contributing Guide for details on:
Reporting bugs & features
Development setup
Contributing via Pull Requests
Code of Conduct
Reporting of security issues
Stay in touch with the team
Come meet the Strands team and other users on Discord
License
This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
Security
See CONTRIBUTING for more information.
Available Tools
2 toolsfetch_docA
Read documentation pages with smart sectioning for token efficiency.
Two modes of operation:
TOC mode (omit section): Returns a table of contents with section IDs, titles, summaries, and the document's preamble so you can decide which part to read.
Section mode (provide section): Returns the full markdown content of one section, identified by the ID from the TOC (e.g., "3" or "3.2").
For small documents (under ~8KB), the full content is returned directly regardless of mode, since sectioning would add overhead without benefit.
Recommended workflow:
search_docs("your query") - find relevant URLs
fetch_doc(uri="...") - see structure, preamble, and section summaries
fetch_doc(uri="...", section="3") - read the section you need
Args: uri: Document URL (must be under https://strandsagents.com/). If empty, returns a catalog of all available document URLs with titles. section: Section ID from the TOC (e.g., "3" or "3.2"). Omit to get the table of contents.
Returns: When section is omitted (TOC mode): - url, title: Document metadata - preamble: Introductory text between page title and first section - sections: List of sections with id, level, title, summary, children
When section is provided:
- url, title: Document metadata
- section_id: Requested section ID
- section_title: Section heading text
- content: Full markdown content of the section
For small documents (under ~8KB):
- url, title: Document metadata
- document_small: true
- content: Full document content (returned automatically)
On error:
- error: Error description
- url: Requested URL
Errors are returned for unsupported URLs and failed page fetches. For
sectioned documents, unknown section IDs also return an error; `section`
is ignored when the full document is returned automatically.| Name | Required | Description | Default |
|---|---|---|---|
| uri | No | ||
| section | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description carries the full burden and largely meets it: it discloses the URL restriction to https://strandsagents.com/, the empty-uri catalog fallback, the small-document bypass that silently ignores the section argument, and the error surface for unsupported URLs, failed fetches, and unknown section IDs. What it does not cover is whether responses are cached, rate-limited, or how large a section payload can get, which matters for an agent planning token budget.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The document is long but aggressively front-loaded and scannable: mode enumeration first, workflow second, then Args and Returns blocks. The main redundancy is the Returns section, which restates the response shape that an output schema already defines; trimming that would tighten the definition without losing selection-relevant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-mode fetch tool with zero annotation coverage and zero schema parameter documentation, the description supplies everything an agent needs: mode selection logic, URL scope constraint, the small-document edge case, the empty-uri catalog path, and the error taxonomy. The presence of an output schema makes the enumerated return fields partly redundant but not harmful, and no decision-relevant behavior is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must supply all meaning, and it does: uri is defined as a URL constrained to a specific domain with a documented empty-string sentinel behavior ('returns a catalog of all available document URLs with titles'), and section is defined as an ID sourced from the TOC with example formats ('3' or '3.2') and the explicit default of omitting it. Both parameters, including their non-obvious defaults, are fully disambiguated beyond the bare schema types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource ('Read documentation pages') modified by a distinctive mechanism ('smart sectioning for token efficiency'), then enumerates the two operating modes with concrete return shapes for each. It is immediately distinguishable from the sibling search_docs, which is explicitly positioned as the discovery step upstream of this fetch step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It spells out exactly when each mode fires (omit section vs. provide section), names the boundary condition that overrides both (~8KB documents return full content regardless of mode), and provides a numbered three-step workflow that routes the agent between search_docs and two successive calls to this tool. Nothing about selection is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_docsA
Search the curated documentation catalog.
The catalog contains Strands Agents user guides, API reference pages, and examples. Ranking starts from document titles and also considers page content once a page has been fetched (hydrated), so both title-like keywords ("bedrock model", "MCP tools") and body terms ("guardrail", "temperature") work. The top results are fetched on demand to hydrate the index and provide content snippets.
Call fetch_doc with a result URL to read the page or one of its sections.
Args: query: Search query string (e.g., "bedrock model", "tell me about a2a", "how to use MCP tools") k: Maximum number of results to return (default: 5)
Returns: List of dictionaries containing: - url: Document URL - title: Display title - score: Unbounded weighted TF-IDF score. Higher is better within this result set; do not interpret it as a probability or compare it across different queries. - snippet: Contextual content preview
Returns an empty list when no document matches. If a result page
cannot be fetched, its title is used as the snippet.| Name | Required | Description | Default |
|---|---|---|---|
| k | No | ||
| query | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden and does substantial work: it discloses the lazy-hydration model (top results fetched on demand), the dual title/body ranking behavior, and the graceful-degradation path where a failed fetch falls back to the title as the snippet. It does not discuss rate limits or fetch failures beyond that fallback, but the important non-obvious behaviors are covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded core sentence, then ranking behavior, then the handoff to fetch_doc, then Args/Returns blocks — a logical order an agent can scan. The Returns block is somewhat verbose relative to its value since an output schema already exists, but nothing is padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter search tool with a sibling and an output schema, this is close to complete: it explains scoring semantics (unbounded TF-IDF, comparable only within a result set, not a probability) and the empty-result case. The Returns enumeration largely restates the output schema, which is the only redundant element.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate and largely does: `query` is illustrated with three distinct natural-language/keyword phrasings, and `k` is defined as the maximum number of results with its default of 5. The remaining gap is minor — no guidance on sensible `k` ranges or query length.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ("Search the curated documentation catalog") and immediately scopes what the catalog holds — user guides, API reference pages, examples. It also distinguishes itself from the sibling by explicitly delegating page reading to fetch_doc, so an agent can pick between the two without opening a schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete guidance on both directions: use search_docs with title-like keywords ("bedrock model", "MCP tools") or body terms, then "Call fetch_doc with a result URL to read the page or one of its sections." It lacks an explicit when-not case (e.g., when a URL is already known, skip straight to fetch_doc), which keeps it just short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
v0.3.0- First observed
fetch_doc - First observed
search_docs
TDQS
Scored across 2 tools
The two tools have clearly distinct purposes: search_docs discovers relevant documentation URLs, while fetch_doc reads a specific page or section. The descriptions explicitly document the recommended search-then-fetch workflow, leaving little ambiguity.
Both tool names follow a consistent verb_noun snake_case pattern: search_docs and fetch_doc. The slight singular/plural difference is natural and does not create confusion.
Two tools is slightly below the typical 3-15 range, but for a focused documentation search-and-read server this is a clean, well-scoped surface. Each tool clearly earns its place.
The server covers the full retrieval lifecycle: search for documents, list catalog URLs, inspect document structure via TOC, and read specific sections or full small documents. No obvious documentation-access gaps remain.
Maintenance
Related MCP Connectors
Search and read the Metabind documentation: MCP Apps, BindJS, the SDKs, the CLI, and the APIs.
Agentic search over your Dewey document collections from any MCP-compatible client.
Search and read Vector Panda docs: API operations, pricing, storage tiers, measured benchmarks.
Search and read Lynta's public documentation.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to search, read, and traverse documentation bundles in Open Knowledge Format via MCP tools.705 npm75MIT
- AlicenseAqualityBmaintenanceSearch and retrieve Agent2Agent (A2A) protocol documentation using full-text search and section filtering.2MIT
- FlicenseNot gradedqualityAmaintenanceEnables AI clients to search and retrieve current technical documentation from major agent frameworks through a standardized MCP tool, supporting both stdio and SSE transports.-
- FlicenseNot gradedqualityAmaintenanceEnables AI agents to search and retrieve current technical documentation for frameworks such as LangChain, LlamaIndex, AutoGen, Agno, OpenAI Agents SDK, MCP, Camel AI, and CrewAI through MCP tools over stdio or SSE.-