Which integrations are available for this server?

Enables searching and retrieving Stack Overflow questions, answers, and comments for programming solutions.

How do I use stackoverflow-mcp-server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@stackoverflow-mcp-server Search Stack Overflow for Python asyncio examples" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

stackoverflow-mcp-server

by CodexVeritax

Overview Schema Related Servers Score Discussions

Python

Remote

Stack Overflow MCP Server

Python Version License

This Model Context Protocol (MCP) server enables AI assistants like Claude to search and access Stack Overflow content through a standardized protocol, providing seamless access to programming solutions, error handling, and technical knowledge.

NOTE

The Stack Overflow MCP Server is currently in Beta. We welcome your feedback and encourage you to report any bugs by opening an issue.

Features

🔍 Multiple Search Methods: Search by query, error message, or specific question ID
📊 Advanced Filtering: Filter results by tags, score, accepted answers, and more
🧩 Stack Trace Analysis: Parse and find solutions for error stack traces
📝 Rich Formatting: Get results in Markdown or JSON format
💬 Comments Support: Optionally include question and answer comments
⚡ Rate Limiting: Built-in protection to respect Stack Exchange API quotas

Example Prompts and Use Cases

Here are some example prompts you can use with Claude when the Stack Overflow MCP server is integrated:

Tool	Example Prompt	Description
`search_by_query`	"Search Stack Overflow for Django pagination best practices"	Finds the most relevant questions and answers about Django pagination techniques
`search_by_query`	"Find Python asyncio examples with tags python and asyncio"	Searches for specific code examples filtering by multiple tags
`search_by_error`	"Why am I getting 'TypeError: object of type 'NoneType' has no len()' in Python?"	Finds solutions for a common Python error
`get_question`	"Get Stack Overflow question 53051465 about React hooks"	Retrieves a specific question by ID, including all answers
`analyze_stack_trace`	"Fix this error: ReferenceError: useState is not defined at Component in javascript"	Analyzes JavaScript error to find relevant solutions
`advanced_search`	"Find highly rated answers about memory leaks in C++ with at least 10 upvotes"	Uses advanced filtering to find high-quality answers

Related MCP server: Hivemind

Prerequisites

Before using this MCP server, you need to:

Get a Stack Exchange API key (see below)
Have Python 3.10+ installed
Install uv (recommended)

Getting a Stack Exchange API Key

To use this server effectively, you'll need a Stack Exchange API key:

Go to Stack Apps OAuth Registration
Fill out the form with your application details:
- Name: "Stack Overflow MCP" (or your preferred name)
- Description: "MCP server for accessing Stack Overflow"
- OAuth Domain: "localhost" (for local usage)
- Application Website: Your website or leave blank
Submit the form
Copy your API Key (shown as "Key" on the next page)

This API key is not considered a secret and may be safely embedded in client-side code or distributed binaries. It simply allows you to receive a higher request quota when making requests to the Stack Exchange API.

Installation

Installing from PyPI

Stackoverflow PyPI page

# Using pip
pip install stackoverflow-mcp

# OR Using uv
uv venv
uv pip install stackoverflow-mcp

# OR using uv wihtout an venv
uv pip install stackoverflow-mcp --system

Installing from Source

# Clone the repository
git clone https://github.com/yourusername/stackoverflow-mcp-server.git
cd stackoverflow-mcp-server

# Install with uv
uv venv
uv pip install -e .

Adding to Claude Desktop

To run the Stack Overflow MCP server with Claude Desktop:

Download Claude Desktop.
Launch Claude and navigate to: Settings > Developer > Edit Config.
Update your claude_desktop_config.json file with the following configuration:

{
  "mcpServers": {
    "stack-overflow": {
      "command": "uv",
      "args": ["run", "-m", "stackoverflow_mcp"],
      "env": {
        "STACK_EXCHANGE_API_KEY": "your_API_key"
      }
    }
  }
}

You can also specify a custom directory:

{
  "mcpServers": {
    "stack-overflow": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/stackoverflow-mcp-server",
        "run",
        "main.py"
      ],
      "env": {
        "STACK_EXCHANGE_API_KEY": "your_api_key_here"
      }
    }
  }
}

Configuration

Environment Variables

The server can be configured using these environment variables:

# Required
STACK_EXCHANGE_API_KEY=your_api_key_here

# Optional
MAX_REQUEST_PER_WINDOW=30     # Maximum requests per rate limit window
RATE_LIMIT_WINDOW_MS=60000    # Rate limit window in milliseconds (1 minute)
RETRY_AFTER_MS=2000           # Delay after hitting rate limit

Using a .env File

You can create a .env file in the project root:

STACK_EXCHANGE_API_KEY=your_api_key_here
MAX_REQUEST_PER_WINDOW=30
RATE_LIMIT_WINDOW_MS=60000
RETRY_AFTER_MS=2000

Usage

Available Tools

The Stack Overflow MCP server provides the following tools:

1. search_by_query

Search Stack Overflow for questions matching a query.

Parameters:
- query: The search query
- tags: Optional list of tags to filter by (e.g., ["python", "pandas"])
- excluded_tags: Optional list of tags to exclude
- min_score: Minimum score threshold for questions
- has_accepted_answer: Whether questions must have an accepted answer
- include_comments: Whether to include comments in results
- response_format: Format of response ("json" or "markdown")
- limit: Maximum number of results to return

2. search_by_error

Search Stack Overflow for solutions to an error message.

Parameters:
- error_message: The error message to search for
- language: Programming language (e.g., "python", "javascript")
- technologies: Related technologies (e.g., ["react", "django"])
- min_score: Minimum score threshold for questions
- include_comments: Whether to include comments in results
- response_format: Format of response ("json" or "markdown")
- limit: Maximum number of results to return

3. get_question

Get a specific Stack Overflow question by ID.

Parameters:
- question_id: The Stack Overflow question ID
- include_comments: Whether to include comments in results
- response_format: Format of response ("json" or "markdown")

4. analyze_stack_trace

Analyze a stack trace and find relevant solutions on Stack Overflow.

Parameters:
- stack_trace: The stack trace to analyze
- language: Programming language of the stack trace
- include_comments: Whether to include comments in results
- response_format: Format of response ("json" or "markdown")
- limit: Maximum number of results to return

5. advanced_search

Advanced search for Stack Overflow questions with many filter options.

Parameters:
- query: Free-form search query
- tags: List of tags to filter by
- excluded_tags: List of tags to exclude
- min_score: Minimum score threshold
- title: Text that must appear in the title
- body: Text that must appear in the body
- answers: Minimum number of answers
- has_accepted_answer: Whether questions must have an accepted answer
- sort_by: Field to sort by (activity, creation, votes, relevance)
- include_comments: Whether to include comments in results
- response_format: Format of response ("json" or "markdown")
- limit: Maximum number of results to return

Development

This section is for contributors who want to develop or extend the Stack Overflow MCP server.

Setting Up Development Environment

# Clone the repository
git clone https://github.com/yourusername/stackoverflow-mcp-server.git
cd stackoverflow-mcp-server

# Install dev dependencies
uv pip install -e ".[dev]"

Running Tests

# Run all tests
pytest

# Run specific test modules
pytest tests/test_formatter.py
pytest tests/test_server.py

# Run tests with coverage report
pytest --cov=stackoverflow_mcp

Project Structure

stackoverflow-mcp-server/
├── stackoverflow_mcp/          # Main package
│   ├── __init__.py
|   |── __main__.py             # Entry point
│   ├── api.py                  # Stack Exchange API client
│   ├── env.py                  # Environment configuration
│   ├── formatter.py            # Response formatting utilities
│   ├── server.py               # MCP server implementation
│   └── types.py                # Data classes
├── tests/                      # Test suite
│   ├── api/
│   │   └── test_search.py      # API search tests
│   ├── test_formatter.py       # Formatter tests
│   ├── test_general_api_health.py  # API health tests
│   └── test_server.py          # Server tests
├── pyproject.toml              # Package configuration
├── api_query.py                # testing stackexchange outside of MCP context
├── LICENSE                     # License file
└── README.md                   # This file

Contributing

Contributions are welcome! Here's how you can contribute:

Fork the repository
Create a feature branch: git checkout -b feature/my-feature
Commit your changes: git commit -am 'Add new feature'
Push to the branch: git push origin feature/my-feature
Submit a pull request

Please make sure to update tests as appropriate and follow the project's coding style.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Available Tools

5 tools

advanced_searchA

Advanced search for Stack Overflow questions with many filter options.

Args:
    query (Optional[str]): Free-form search query
    tags (Optional[List[str]]): List of tags to filter by
    excluded_tags (Optional[List[str]]): List of tags to exclude
    min_score (Optional[int]): Minimum score threshold
    title (Optional[str]): Text that must appear in the title
    body (Optional[str]): Text that must appear in the body
    answers (Optional[int]): Minimum number of answers
    has_accepted_answer (Optional[bool]): Whether questions must have an accepted answer
    views (Optional[int]): Minimum number of views
    url (Optional[str]): URL that must be contained in the post
    user_id (Optional[int]): ID of the user who must own the questions
    is_closed (Optional[bool]): Whether to return only closed or open questions
    is_wiki (Optional[bool]): Whether to return only community wiki questions
    is_migrated (Optional[bool]): Whether to return only migrated questions
    has_notice (Optional[bool]): Whether to return only questions with post notices
    from_date (Optional[datetime]): Earliest creation date
    to_date (Optional[datetime]): Latest creation date
    sort_by (Optional[str]): Field to sort by (activity, creation, votes, relevance)
    include_comments (Optional[bool]): Whether to include comments in results
    response_format (Optional[str]): Format of response ("json" or "markdown")
    limit (Optional[int]): Maximum number of results to return
    ctx (Context): The context is passed automatically by the MCP
    
Returns:
    str: Formatted search results

ParametersJSON Schema

Name	Required	Default
`query`	No
`tags`	No
`excluded_tags`	No
`min_score`	No
`title`	No
`body`	No
`answers`	No
`has_accepted_answer`	No
`views`	No
`url`	No
`user_id`	No
`is_closed`	No
`is_wiki`	No
`is_migrated`	No
`has_notice`	No
`from_date`	No
`to_date`	No
`sort_by`	No	votes
`include_comments`	No
`response_format`	No	markdown
`limit`	No

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description covers parameter details and return format but omits broader behavioral traits like side effects, authentication needs, rate limits, or explicit read-only indication. It provides adequate but not comprehensive transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a concise introductory sentence followed by a parameter list and return statement. It is front-loaded and necessary, though the lengthy parameter list is unavoidable due to tool complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 21 parameters, no output schema, and no annotations, the description covers parameters and return type but lacks details on parameter interactions, pagination, error handling, or response structure. It is adequate but not fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Given 0% schema_description_coverage, the description effectively adds meaning by listing all 21 parameters with brief, clear explanations (e.g., 'List of tags to filter by'). It compensates for missing schema descriptions, though some parameter semantics could be deeper.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it performs 'Advanced search for Stack Overflow questions with many filter options,' using a specific verb and resource. This distinguishes it from simpler sibling tools like search_by_query or search_by_error.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide explicit guidance on when to use this tool versus alternatives. It lacks when-not-to-use scenarios, prerequisites, or comparisons to sibling tools, leaving the agent to infer based on parameter lists.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

analyze_stack_traceA

Analyze a stack trace and find relevant solutions on Stack Overflow.

Args:
    stack_trace (str): The stack trace to analyze
    language (str): Programming language of the stack trace
    excluded_tags (Optional[List[str]]): Optional list of tags to exclude
    min_score (Optional[int]): Minimum score threshold for questions
    has_accepted_answer (Optional[bool]): Whether questions must have an accepted answer
    answers (Optional[int]): Minimum number of answers
    include_comments (Optional[bool]): Whether to include comments in results
    response_format (Optional[str]): Format of response ("json" or "markdown")
    limit (Optional[int]): Maximum number of results to return
    ctx (Context): The context is passed automatically by the MCP
    
Returns:
    str: Formatted search results

ParametersJSON Schema

Name	Required	Default
`stack_trace`	Yes
`language`	Yes
`excluded_tags`	No
`min_score`	No
`has_accepted_answer`	No
`answers`	No
`include_comments`	No
`response_format`	No	markdown
`limit`	No

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the high-level purpose and parameter explanations, omitting details such as side effects, permissions, rate limits, or how the stack trace is processed. The absence of such information limits transparency for a tool that likely queries an external API.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is highly concise and well-structured, with a short introductory sentence followed by a clean bullet-point list of parameters. It front-loads the purpose and uses minimal prose, earning every sentence's place. No extraneous information is present.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (9 parameters) and lack of annotations and output schema, the description adequately explains parameter semantics but fails to describe the return format in sufficient detail ('Formatted search results' is vague). It also does not explain the overall workflow or how results are structured, leaving gaps for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description includes an Args section with a one-line explanation for each of the 9 parameters, adding meaning beyond the input schema (which lacks descriptions). All parameters are covered, with clear explanations of their roles (e.g., 'Programming language of the stack trace' for 'language'). However, some explanations are minimal and could benefit from examples or constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('analyze') and resource ('stack trace'), and explicitly identifies the target platform (Stack Overflow). It distinguishes itself from sibling tools like 'search_by_error' and 'search_by_query' by focusing on stack trace analysis.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide any guidance on when to use this tool versus its siblings (e.g., 'advanced_search', 'search_by_error'). It lacks explicit 'when-to-use' or 'when-not-to-use' instructions, leaving the AI agent without context for choosing the appropriate tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_questionA

Get a specific Stack Overflow question by ID.

Args:
    question_id (int): The Stack Overflow question ID
    include_comments (Optional[bool]): Whether to include comments in results
    response_format (Optional[str]): Format of response ("json" or "markdown")
    ctx (Context): The context is passed automatically by the MCP

Returns:
    str: Formatted question details

ParametersJSON Schema

Name	Required	Default
`question_id`	Yes
`include_comments`	No
`response_format`	No	markdown

TDQS

A3.6/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so description carries full burden. It only states the basic action and parameters, lacking disclosure of behavioral traits like error handling, authentication needs, rate limits, or whether it's read-only.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is front-loaded with the main sentence and includes a structured Args block. It is appropriately sized, though the Python docstring format is non-standard for MCP and could be condensed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description states 'Returns: str: Formatted question details' which is minimal. It does not specify what fields are included or any pagination/error behavior, leaving gaps for a tool with no annotations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so description must compensate. The Args section explains each parameter (question_id, include_comments, response_format) with types and optionality, adding meaning beyond the schema. However, it does not reiterate default values present in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description explicitly states 'Get a specific Stack Overflow question by ID', which is a clear verb+resource. It distinguishes from sibling tools (advanced_search, search_by_error, etc.) which are search-oriented.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies using this tool when you have a question ID, but does not provide explicit when-to-use or when-not-to-use guidance. No mention of alternatives or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_by_errorA

Search Stack Overflow for solutions to an error message

Args:
    error_message (str): The error message to search for
    language (Optional[str]): Programming language (e.g., "python", "javascript")
    technologies (Optional[List[str]]): Related technologies (e.g., ["react", "django"])
    excluded_tags (Optional[List[str]]): Optional list of tags to exclude
    min_score (Optional[int]): Minimum score threshold for questions
    has_accepted_answer (Optional[bool]): Whether questions must have an accepted answer
    answers (Optional[int]): Minimum number of answers
    include_comments (Optional[bool]): Whether to include comments in results
    response_format (Optional[str]): Format of response ("json" or "markdown")
    limit (Optional[int]): Maximum number of results to return
    ctx (Context): The context is passed automatically by the MCP

Returns:
    str: Formatted search results

ParametersJSON Schema

Name	Required	Default
`error_message`	Yes
`language`	No
`technologies`	No
`excluded_tags`	No
`min_score`	No
`has_accepted_answer`	No
`answers`	No
`include_comments`	No
`response_format`	No	markdown
`limit`	No

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description partially covers behavior by mentioning it searches for solutions and returns formatted results. However, it does not disclose rate limits, authentication, or other potential side effects. It is adequate but not thorough.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with one purpose line followed by a parameter list. The Args/Returns structure is clear and properly front-loaded. Each line adds information without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 10 parameters, no output schema, and no annotations, the description adequately covers input semantics and return format. It is complete for a search tool, though it could mention result behavior (e.g., sorting).

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description carries full burden. It provides clear, meaningful descriptions for all 10 parameters (e.g., 'The error message to search for', 'Programming language'), adding value beyond the schema's bare type definitions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Search Stack Overflow for solutions to an error message', which is a specific verb+resource combination. It distinguishes from sibling tools like search_by_query (general) and get_question (single question).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus siblings like advanced_search or analyze_stack_trace. There is no context on preferred use cases or exclusion criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_by_queryB

Search Stack Overflow for questions matching a query.

Args:
    query (str): The search query
    tags (Optional[List[str]]): Optional list of tags to filter by (e.g., ["python", "pandas"])
    excluded_tags (Optional[List[str]]): Optional list of tags to exclude
    min_score (Optional[int]): Minimum score threshold for questions
    title (Optional[str]): Text that must appear in the title
    body (Optional[str]): Text that must appear in the body
    has_accepted_answer (Optional[bool]): Whether questions must have an accepted answer
    answers (Optional[int]): Minimum number of answers
    sort_by (Optional[str]): Field to sort by (activity, creation, votes, relevance)
    include_comments (Optional[bool]): Whether to include comments in results
    response_format (Optional[str]): Format of response ("json" or "markdown")
    limit (Optional[int]): Maximum number of results to return
    ctx (Context): The context is passed automatically by the MCP

Returns:
    str: Formatted search results

ParametersJSON Schema

Name	Required	Default
`query`	Yes
`tags`	No
`excluded_tags`	No
`min_score`	No
`title`	No
`body`	No
`has_accepted_answer`	No
`answers`	No
`sort_by`	No	votes
`include_comments`	No
`response_format`	No	markdown
`limit`	No

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description only documents parameters and return format. It does not disclose behavioral traits such as rate limits, authentication needs, or side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with Args and Returns sections and is front-loaded with the main purpose. However, it is somewhat lengthy due to detailed parameter documentation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (12 parameters) and lack of output schema, the description adequately explains all inputs and return format. It covers the essential context for invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description fully compensates by providing clear, concise explanations for each of the 12 parameters, including types, defaults, and purpose.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool searches Stack Overflow for questions matching a query. It specifies verb+resource, but does not differentiate from sibling tools like advanced_search.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description lacks any guidance on when to use this tool versus alternatives. No when/when-not information is provided.

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. Dates show when Glama detected each change.

5 tool updatesv0.1.3Jun 11, 2026
- First observedadvanced_search
- First observedanalyze_stack_trace
- First observedget_question
- First observedsearch_by_error
- First observedsearch_by_query

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.6/5.0

Disambiguation4/5

Tools have distinct purposes: advanced_search for comprehensive filtering, search_by_query for simpler queries, search_by_error for errors, analyze_stack_trace for stack traces, and get_question for specific retrieval. There is some overlap between advanced_search and search_by_query, but descriptions clearly differentiate them.

Naming Consistency5/5

All tool names follow a consistent snake_case verb_noun pattern (e.g., advanced_search, get_question, search_by_error). No mixing of conventions, making it easy to predict naming for hypothetical additional tools.

Tool Count4/5

5 tools is slightly below average but appropriate for a focused search-only server. Each tool covers a key use case (general search, error search, stack trace analysis, specific question retrieval). Could benefit from one more tool (e.g., for answers) but current count is reasonable.

Completeness3/5

Covers main search scenarios well, including advanced filtering, error messages, and stack traces. However, lacks tools for retrieving answers separately or exploring tags/users. The presence of two very similar search tools (advanced_search vs search_by_query) suggests slight redundancy rather than full coverage.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Stack Overflow MCP Server
com.stackoverflow.mcp
Access Stack Overflow's trusted and verified technical questions and answers.
Search Documentation Access Developer Tools
28
Searchapi AOAuth
io.searchapi
Give AI assistants access to real-time data. Search the web, compare flights, find hotels, and more.
Search Browser Automation Travel & Transportation
6
stackexchange-mcp-server A
io.github.cyanheads
Search Stack Exchange questions, fetch Q&A threads as markdown, look up tag FAQs and user profiles.
Search Research & Data
522
Ragora A
io.github.mregmi
Search your knowledge bases from any AI assistant using hybrid RAG.
RAG Systems Search Knowledge & Memory
2

Related MCP Servers

Sourcegraph MCP Server
Code Analysis Search
najva-ai
A
license
Not graded
quality
F
maintenance
Provides AI-enhanced code search capabilities by integrating with Sourcegraph, allowing AI assistants to search across multiple repositories and codebases with advanced query syntax.
Updated 9 months ago (2025-11-25 08:00 UTC)
40
MIT
Hivemind
Search Developer Tools Documentation Access
Kevthetech143
F
license
Not graded
quality
D
maintenance
Provides instant access to a searchable knowledge base of 16,000+ community-driven troubleshooting solutions for common coding problems. Includes community feedback and smart ranking to help AI assistants find the most effective solutions.
Updated 9 months ago (2025-11-29 23:08 UTC)
-
mcp-stackexchange
Search Research & Data
pipeworx-io
A
license
Not graded
quality
C
maintenance
Wraps the StackExchange API v2.3 to enable reading StackExchange data (questions, answers, etc.) without authentication. Allows AI agents to query StackExchange content through natural language or direct tool calls.
Updated 11 days ago (2026-08-26 17:43 UTC)
13
1
MIT
Kindly Web Search MCP Server
Search Web Scraping Browser Automation
Shelpuk-AI-Technology-Consulting
A
license
Not graded
quality
B
maintenance
Provides web search and content retrieval optimized for AI coding assistants, returning full conversations and structured content from StackOverflow, GitHub Issues, arXiv, and Wikipedia in a single call.
Updated 12 hours ago (2026-09-05 19:35 UTC)
382
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/CodexVeritax/stackoverflow-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server