Which integrations are available for this server?

Provides tools for accessing Stack Exchange network data, including questions and answers, via the Stack Exchange API. Provides tools for searching questions, fetching answers, and exploring content on Stack Overflow through the Stack Exchange API.

How do I use stack-overflow-mcp-light?

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., "@stack-overflow-mcp-light search for Python async await 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.

stack-overflow-mcp-light

by midodimori

Overview Schema Related Servers Score Discussions

Python

Remote

Stack Overflow MCP Server

A Model Context Protocol (MCP) server that provides comprehensive tools for interacting with Stack Overflow through the Stack Exchange API. This server enables AI assistants to search questions, get detailed answers, and explore Stack Overflow content through a standardized interface.

License: MIT Python 3.11+ FastMCP

🚀 Features

Question Search - Advanced search with multiple filters and sorting options
Question Details - Get comprehensive information including answers with body content
Tag-based Search - Find questions by specific tags
Top Answers - Retrieve highly-voted answers from the community
Type Safety - Full Pydantic validation with structured response models
Error Handling - Comprehensive error reporting and graceful failure modes

Related MCP server: evo-scry

📦 Installation

Using uvx (Recommended)

uvx stack-overflow-mcp-light

Using uv

uv add stack-overflow-mcp-light
uv run stack-overflow-mcp-light

Using pip

pip install stack-overflow-mcp-light
stack-overflow-mcp-light

⚙️ Configuration

Environment Variables

STACK_EXCHANGE_API_KEY (Optional): Stack Exchange API key for increased rate limits. Get one at Stack Apps
STACK_OVERFLOW_MCP_SHOW_LOGS (Optional): Set to "true" to enable detailed logging

💡 API Key: While optional, an API key significantly increases your rate limits from 300 to 10,000 requests per day.

Transport Types

stdio (default) - Standard input/output, client launches server automatically
http (recommended for remote) - Modern HTTP transport (aliases: streamable-http, streamable_http)
sse (legacy) - Server-Sent Events transport (deprecated)

🚀 Quick Start (uvx)

Stdio Transport

{
  "mcpServers": {
    "stack-overflow": {
      "command": "uvx",
      "args": ["--no-progress", "stack-overflow-mcp-light"],
      "env": {
        "STACK_EXCHANGE_API_KEY": "your_api_key_here",
        "STACK_OVERFLOW_MCP_SHOW_LOGS": "false"
      }
    }
  }
}

HTTP Transport

Start server:

export STACK_EXCHANGE_API_KEY="your_api_key_here"
uvx --no-progress stack-overflow-mcp-light --transport http --port 8000 --host 0.0.0.0

Client config:

{
  "mcpServers": {
    "stack-overflow": {
      "url": "http://localhost:8000/mcp",
      "transport": "http"
    }
  }
}

SSE Transport

Start server:

export STACK_EXCHANGE_API_KEY="your_api_key_here"
uvx --no-progress stack-overflow-mcp-light --transport sse --port 8000 --host 0.0.0.0

Client config:

{
  "mcpServers": {
    "stack-overflow": {
      "url": "http://localhost:8000/sse",
      "transport": "sse"
    }
  }
}

🔧 Alternative Commands

Stdio with `uv run --with`

{
  "mcpServers": {
    "stack-overflow": {
      "command": "uv",
      "args": ["run", "--with", "stack-overflow-mcp-light", "stack-overflow-mcp-light"],
      "env": {
        "STACK_EXCHANGE_API_KEY": "your_api_key_here",
        "STACK_OVERFLOW_MCP_SHOW_LOGS": "false"
      }
    }
  }
}

Stdio with `uv run --directory` (Local Development)

{
  "mcpServers": {
    "stack-overflow": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/stack-overflow-mcp-light", "stack-overflow-mcp-light"],
      "env": {
        "STACK_EXCHANGE_API_KEY": "your_api_key_here",
        "STACK_OVERFLOW_MCP_SHOW_LOGS": "true"
      }
    }
  }
}

Stdio with `pip` Install

{
  "mcpServers": {
    "stack-overflow": {
      "command": "stack-overflow-mcp-light",
      "args": [],
      "env": {
        "STACK_EXCHANGE_API_KEY": "your_api_key_here",
        "STACK_OVERFLOW_MCP_SHOW_LOGS": "false"
      }
    }
  }
}

HTTP/SSE Alternative Commands

All transport types can use these alternative commands:

# Using uv run --with
export STACK_EXCHANGE_API_KEY="your_api_key_here"
uv run --with stack-overflow-mcp-light stack-overflow-mcp-light --transport http --port 8000

# Using uv run --directory (local development)
export STACK_EXCHANGE_API_KEY="your_api_key_here"
cd /path/to/stack-overflow-mcp-light
uv run stack-overflow-mcp-light --transport http --port 8000

# Using pip install
export STACK_EXCHANGE_API_KEY="your_api_key_here"
stack-overflow-mcp-light --transport http --port 8000

🛠️ Available Tools

❓ Question Tools (3 tools)

`search_questions`

Search Stack Overflow questions with advanced filters.

Input: Search parameters including:
- q - Free-form text search
- tagged - Semi-colon delimited list of tags
- intitle - Search in question titles
- nottagged - Exclude these tags
- body - Text in question body
- accepted - Has accepted answer (boolean)
- closed - Question is closed (boolean)
- answers - Minimum number of answers
- views - Minimum view count
- sort - Sort criteria ("activity", "votes", "creation", "hot", "week", "month", "relevance")
- order - Sort order ("asc" or "desc")
- page - Page number (1-25)
- page_size - Items per page (1-100)
Output: Array of question items with essential fields:
- question_id - Question ID
- is_answered - Whether the question has answers
- score - Question score
- link - Link to the question
- title - Question title

`fetch_question_answers`

Fetch a specific question, always including answers with body content sorted by the specified criteria.

Input: Question details request including:
- question_id - Question ID (required)
- sort - Answer sort criteria ("activity", "votes", "creation") - defaults to "votes"
- order - Sort order ("asc" or "desc") - defaults to "desc"
- page_size - Maximum number of answers to return (1-100) - defaults to 30
Output: QuestionItem with detailed information including:
- question_id - Question ID
- is_answered - Whether the question has answers
- score - Question score
- link - Link to the question
- title - Question title
- answers - Array of AnswerItem objects with:
  - answer_id - Answer ID
  - is_accepted - Whether the answer is accepted
  - score - Answer score
  - body - Answer body content

`search_questions_by_tag`

Search questions that have a specific tag.

Input: tag (tag name), sort, order, page, page_size
Output: Array of question items with essential fields:
- question_id - Question ID
- is_answered - Whether the question has answers
- score - Question score
- link - Link to the question
- title - Question title

🧪 Testing

The project includes comprehensive tests covering all tools:

# Run all tests
make test

# Run with coverage
make test-cov

# Run specific test categories
uv run pytest tests/test_server.py::TestQuestionTools -v

🔧 Development

Setup Development Environment

# Clone the repository
git clone https://github.com/midodimori/stack-overflow-mcp-light.git
cd stack-overflow-mcp-light

# Install with development dependencies
make install-dev

# Run tests
make test

# Format and lint code
make format

# Check code style and types
make lint

# Run the server locally
make run

# See all available commands
make help

Project Structure

stack-overflow-mcp-light/
├── src/stack_overflow_mcp_light/
│   ├── __init__.py
│   ├── server.py          # MCP server implementation
│   ├── logging_config.py  # Logging configuration
│   ├── models/            # Pydantic models
│   │   ├── __init__.py
│   │   ├── requests.py    # Request models
│   │   └── responses.py   # Response models
│   └── tools/             # Tool implementations
│       ├── __init__.py
│       ├── base_client.py # Base client for Stack Exchange API
│       └── questions.py   # Question search and retrieval tools
├── tests/
│   ├── test_server.py     # Tool function tests
│   └── test_mcp_integration.py  # MCP integration tests
├── pyproject.toml         # Project configuration
└── README.md

📚 API Reference

Question Sort Options

activity: Sort by last activity date (default)
votes: Sort by question score
creation: Sort by creation date
hot: Sort by current hotness
week: Sort by weekly activity
month: Sort by monthly activity
relevance: Sort by search relevance

Answer Sort Options

activity: Sort by last activity date (default)
votes: Sort by answer score
creation: Sort by creation date

Sort Order

desc: Descending order (default)
asc: Ascending order

🤝 Contributing

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📄 License

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

⚠️ Disclaimer

This software is provided for educational and informational purposes only. This tool interacts with Stack Overflow's public API and respects their rate limits and terms of service. The authors are not responsible for any misuse of the Stack Exchange API or violation of their terms of service.

🔗 Links

📞 Support

For questions, issues, or contributions:

Open an issue on GitHub
Check the Stack Overflow Meta for API-related questions
Review the comprehensive test suite for usage examples

Available Tools

3 tools

fetch_question_answersA

Fetch specific Stack Overflow question with its answers.

Args: request: Question details request with ID and answer sorting options

Returns: Question item with detailed information including answers sorted by the specified criteria with body content

ParametersJSON Schema

Name	Required	Description	Default
`request`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`link`	No	Link to the question
`score`	No	Question score
`title`	No	Question title
`answers`	No	List of answers for the question
`is_answered`	No	Whether the question has answers
`question_id`	No	Question ID

TDQS

A3.6/5.0

Behavior3/5

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

No annotations are provided, so the description carries the transparency burden. It discloses that answers are sorted and include body content, but does not mention pagination, rate limits, authentication, or potential errors. For a read-only fetch tool, this is moderate but not comprehensive.

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 and structured with Args/Returns sections. It contains no fluff, though it could be slightly more efficient. It earns a high score for clarity and brevity.

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?

The description explains the tool's return value (question with sorted answers and body content), which is sufficient given the presence of an output schema. It does not mention edge cases or limitations, but for a simple fetch tool it covers the essential context.

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

Parameters2/5

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

The description only vaguely mentions 'request' with ID and answer sorting options, adding little beyond the input schema which already provides detailed descriptions for question_id, sort, order, and page_size. With 0% schema description coverage, the description should compensate but does not.

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 fetches a specific Stack Overflow question with its answers, using a specific verb and resource. This distinguishes it from sibling search tools, which focus on finding questions rather than retrieving a particular question.

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 usage when you have a specific question ID and want answers, but does not explicitly mention the search siblings or state when not to use this tool. No exclusions or alternatives are provided, so guidance is only implicit.

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

search_questionsC

Search Stack Overflow questions using advanced filters.

Args: request: Question search request with filters and pagination

Returns: List of question items

ParametersJSON Schema

Name	Required	Description	Default
`request`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only states that the tool searches and returns a list, offering no information about read-only safety, authentication requirements, pagination behavior, or any side effects. This is insufficient for an agent to safely invoke the tool.

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, using only three short sections (summary, Args, Returns) with no extraneous words. The structure is clean and front-loaded with the main purpose, making it easy to parse.

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

Completeness2/5

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

Given the complexity of a nested request object with many filters, the description is too thin. It fails to explain when to use this tool versus siblings, does not mention important behaviors like pagination limits or read-only status, and offers no guidance on constructing the request. The output schema may exist, but the description itself leaves significant gaps for an agent.

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

Parameters3/5

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

The description adds a minimal summary of the 'request' parameter as containing filters and pagination, but since the schema description coverage is 0% for the top-level parameter, it does not fully compensate. The nested schema properties are richly described, so the agent can infer structure, but the description adds little beyond the obvious.

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 questions using advanced filters, which specifies both the verb and resource. However, it does not explicitly differentiate from sibling tools like search_questions_by_tag, so it is clear but not fully distinguishing.

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 alternatives such as search_questions_by_tag or fetch_question_answers. It does not mention any exclusions or context for choosing this tool over others, leaving the agent to infer usage from the name alone.

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

search_questions_by_tagA

Search Stack Overflow questions that have a specific tag.

Args: request: Request with tag name, sort options, and pagination

Returns: List of question items with the specified tag

ParametersJSON Schema

Name	Required	Description	Default
`request`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

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 carries the full burden. It states that it returns a list of question items, which is useful. However, it does not disclose any potential side effects (though as a search it is read-only), authentication requirements, rate limits, or error behaviors. The description is minimally transparent but not rich in behavioral detail.

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, using a clear format with Args and Returns sections. It is easy to scan and not overly verbose. Minor redundancy exists between 'specific tag' and 'with the specified tag', but it does not detract significantly from clarity.

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?

The tool is relatively simple, and the output schema likely covers return values. The description does not mention pagination specifics or any edge cases, but the schema provides details. Without annotations, some additional context (e.g., rate limits, typical usage) would improve completeness, but it is adequate for a straightforward search tool.

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

Parameters3/5

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

The description summarizes the single parameter as 'Request with tag name, sort options, and pagination', which provides a high-level overview. Although schema description coverage is low (0%), the schema itself contains detailed descriptions for each field, so the agent can access those. The description adds some semantic framing but does not elaborate on specific fields like order or page_size.

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 explicitly states 'Search Stack Overflow questions that have a specific tag', which clearly defines the action (search), the resource (Stack Overflow questions), and the distinguishing qualifier (specific tag). This differentiates it from sibling tools like search_questions (general search) and fetch_question_answers (fetching answers).

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

Usage Guidelines4/5

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

The description clearly implies the use case: find questions for a specific tag. It does not explicitly mention alternatives or exclusions, but the tag-specific focus is evident from the first line. This provides clear context without stating when not to use it.

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.

3 tool updatesv1.2.0Aug 2, 2026
- First observedfetch_question_answers
- First observedsearch_questions
- First observedsearch_questions_by_tag

Install Server

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

TDQS

B3.4/5.0

Disambiguation3/5

search_questions and search_questions_by_tag overlap because search_questions accepts advanced filters that likely include tag filtering, making the distinction unclear. fetch_question_answers is clearly distinct, retrieving a specific question with answers, but the two search tools create ambiguity.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern: search_questions, search_questions_by_tag, and fetch_question_answers. The 'by_tag' modifier is a clear exception for the second search tool but still follows the same convention, making the naming predictable and uniform.

Tool Count4/5

With 3 tools, the set is on the lean side but appropriate for a 'light' Stack Overflow read-only server. Each tool serves a core purpose without redundancy, and the count is reasonable for the intended narrow scope.

Completeness4/5

The server covers essential read operations: searching questions generically and by tag, and fetching a question with answers. Missing operations like user lookups or comment retrieval are not critical for a lightweight server, but the surface is slightly thin for full Stack Overflow 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

mcp A
ai.llmse
Public MCP server for the LLM Search Engine
Search RAG Systems Developer Tools
102
mcpOAuth
com.bullpenstrategygroup.rotunda
An MCP server that provides congressional transcripts
Government Data Search Open Data
2
Airweave SearchOAuth
io.github.airweave-ai
MCP server for searching Airweave collections with natural language queries.
Search Art & Culture Open Data
25,729
forkast-mcp-docs A
io.github.ForkastPredict
MCP server for querying Forkast documentation
Documentation Access Search Developer Tools
42

Related MCP Servers

StackOverflow MCP Server
Search Documentation Access Developer Tools
NoTalkTech
A
license
A
quality
D
maintenance
Provides seamless access to StackOverflow's Q\&A database through MCP, enabling advanced search, question/answer retrieval, and rate-limit management.
Updated 3 months ago (2026-05-29 11:02 UTC)
5
25
2
MIT
evo-scry
Search Web Scraping
krich11
A
license
Not graded
quality
D
maintenance
MCP server for internet search via direct Google and DuckDuckGo HTML scraping with AI-powered result normalization and optional summarization, requiring no API keys for search.
Updated 5 months ago (2026-04-06 21:02 UTC)
MIT
serp-it
Search Browser Automation Web Scraping
luka-dev
A
license
Not graded
quality
C
maintenance
An MCP server that aggregates web search results from multiple engines and optionally renders pages to Markdown, providing a unified search interface.
Updated 7 months ago (2026-01-31 23:31 UTC)
12
3
ISC
Metaso Search MCP Server
Search Web Scraping
SecretRichGarden
A
license
A
quality
D
maintenance
MCP server for Metaso Search API, providing multi-scope search and webpage reading tools.
Updated 6 months ago (2026-03-05 12:49 UTC)
2
38
2
Apache 2.0

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/midodimori/stack-overflow-mcp-light'

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

Stack Overflow MCP Server

🚀 Features

📦 Installation

Using uvx (Recommended)

Using uv

Using pip

⚙️ Configuration

Environment Variables

Transport Types

🚀 Quick Start (uvx)

Stdio Transport

HTTP Transport

SSE Transport

🔧 Alternative Commands

Stdio with uv run --with

Stdio with uv run --directory (Local Development)

Stdio with pip Install

HTTP/SSE Alternative Commands

🛠️ Available Tools

❓ Question Tools (3 tools)

search_questions

fetch_question_answers

search_questions_by_tag

🧪 Testing

🔧 Development

Setup Development Environment

Project Structure

📚 API Reference

Question Sort Options

Answer Sort Options

Sort Order

🤝 Contributing

📄 License

⚠️ Disclaimer

🔗 Links

📞 Support

Available Tools

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

Stdio with `uv run --with`

Stdio with `uv run --directory` (Local Development)

Stdio with `pip` Install

`search_questions`

`fetch_question_answers`

`search_questions_by_tag`