Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Predictive Market Find arbitrage opportunities in crypto markets"
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.
An MCP (Model Context Protocol) server that aggregates prediction market data from 5 major platforms. Search markets, compare odds, detect arbitrage opportunities, and track predictions through natural language.
Works with Claude Desktop, Claude Code, Cursor, and any MCP-compatible client.
Part of the Claude Code Plugin Marketplace.
Related MCP server: telekash-mcp-server
# Clone and install
git clone https://github.com/EricGrill/mcp-predictive-market.git
cd mcp-predictive-market
uv sync
# Run the server
uv run python -m mcp_predictive_market.serverAdd to your Claude config and start querying markets:
"Find prediction markets about AI regulation"
Feature | Description |
Multi-Platform Search | Query 5 prediction markets simultaneously |
Arbitrage Detection | Find price discrepancies across platforms |
Market Tracking | Build watchlists and monitor odds changes |
Platform Comparison | Side-by-side odds for similar questions |
Unified Data Model | Consistent market schema across all platforms |
Tool | Description |
| Search markets across all platforms by keyword |
| Get available market categories |
| Browse markets in a specific category |
Tool | Description |
| Get current odds for a specific market |
| Side-by-side comparison of similar markets |
Tool | Description |
| Add a market to your watchlist |
| View all tracked markets with current prices |
Tool | Description |
| Detect price discrepancies between platforms |
Platform | URL | Specialization |
Manifold Markets | Play money, wide variety | |
Polymarket | Crypto, high liquidity | |
Metaculus | Science, long-term forecasts | |
PredictIt | US politics | |
Kalshi | CFTC-regulated, real money |
Add to your Claude Desktop config:
Platform | Config Path |
macOS |
|
Windows |
|
Linux |
|
{
"mcpServers": {
"prediction-market": {
"command": "uv",
"args": ["run", "--directory", "/path/to/mcp-predictive-market", "python", "-m", "mcp_predictive_market.server"]
}
}
}Add to your project .mcp.json or ~/.config/claude-code/mcp.json:
{
"mcpServers": {
"prediction-market": {
"command": "uv",
"args": ["run", "--directory", "/path/to/mcp-predictive-market", "python", "-m", "mcp_predictive_market.server"]
}
}
}"Find prediction markets about AI"
"What categories of markets are available?"
"Show me crypto markets on Polymarket"
"Browse politics markets""Get current odds for Manifold market abc123"
"Compare odds for 'Will Bitcoin hit $100k?' across all platforms"
"Show me the probability of a 2024 recession on different platforms""Find arbitrage opportunities with at least 10% spread"
"Are there any markets with significantly different odds across platforms?"
"Show me the biggest price discrepancies right now""Track the Polymarket election market"
"Show all my tracked markets"
"What are the current prices on my watchlist?"# Clone
git clone https://github.com/EricGrill/mcp-predictive-market.git
cd mcp-predictive-market
# Install with dev dependencies
uv sync --extra dev
# Run tests
uv run pytest -v
# Run specific test file
uv run pytest tests/test_integration.py -vsrc/mcp_predictive_market/
├── server.py # MCP server entry point
├── tools.py # Tool handler implementations
├── schema.py # Unified market data models
├── errors.py # Custom exceptions
├── rate_limiter.py # Per-platform rate limiting
├── adapters/ # Platform-specific adapters
│ ├── base.py # Adapter protocol
│ ├── manifold.py
│ ├── polymarket.py
│ ├── metaculus.py
│ ├── predictit.py
│ └── kalshi.py
├── analysis/ # Market analysis modules
│ ├── matching.py # Cross-platform market matching
│ └── arbitrage.py # Arbitrage detection
└── state/ # State management
└── memvid_client.pyPlatform API may be rate-limited - wait and retry
Check platform is online: visit the website directly
Some platforms filter certain market types
Lower the min_spread parameter (default is 5%)
Try broader search terms
Fewer opportunities exist in efficient markets
Verify the market ID format (varies by platform)
Ensure the market hasn't been resolved/closed
Check you're using the correct platform name
Claude Code Plugin Marketplace - Discover more MCP plugins
MCP Proxmox Admin - Manage Proxmox VE through Claude
MCP Memvid State Service - Persistent state for MCP servers
Contributions welcome!
Fork the repository
Create feature branch: git checkout -b feature/my-feature
Make changes and test: uv run pytest
Commit: git commit -m 'Add my feature'
Push: git push origin feature/my-feature
Open a Pull Request
MIT
Browse markets in a specific category
| Name | Required | Description | Default |
|---|---|---|---|
| category | Yes | Category to browse | |
| limit | No | Max markets to return (default 20) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions browsing markets but doesn't disclose behavioral traits such as whether this is a read-only operation, potential rate limits, authentication needs, or what the output looks like (e.g., list format, pagination). This leaves significant gaps for an agent to understand the tool's behavior.
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 description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly.
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?
Given no annotations and no output schema, the description is incomplete. It lacks details on behavioral aspects (e.g., safety, output format) and doesn't compensate for the missing structured data. For a tool with two parameters and siblings, more context is needed to guide proper usage.
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 100%, so the schema already documents both parameters ('category' and 'limit') with descriptions. The description adds no additional meaning beyond implying that 'category' specifies which markets to browse, which is already clear from the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
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 clearly states the action ('browse') and target ('markets in a specific category'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_categories' or 'search_markets', which could also involve browsing or listing markets/categories, so it misses full sibling distinction.
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?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'list_categories' (which might list categories) and 'search_markets' (which might search across categories), there's no indication of context, prerequisites, or exclusions for this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Side-by-side odds comparison for markets matching a query
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query to find markets to compare |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'side-by-side odds comparison,' implying a read-only operation, but doesn't specify if it requires authentication, has rate limits, returns structured data, or handles errors. For a tool with zero annotation coverage, this is a significant gap in transparency.
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 description is a single, efficient sentence: 'Side-by-side odds comparison for markets matching a query.' It is front-loaded with the core purpose and wastes no words, making it highly concise and well-structured for quick understanding.
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?
Given the complexity of odds comparison and the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'side-by-side' entails (e.g., format, data included), how results are returned, or any behavioral traits like performance or limitations. This leaves gaps for an AI agent to use the tool effectively.
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?
The input schema has 100% description coverage, with the 'query' parameter documented as 'Search query to find markets to compare.' The description adds minimal value beyond this, as it only reiterates that the query finds 'markets to compare.' Since the schema does the heavy lifting, the baseline score of 3 is appropriate.
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 clearly states the tool's purpose: 'Side-by-side odds comparison for markets matching a query.' It specifies the verb ('comparison'), resource ('odds'), and scope ('markets matching a query'). However, it doesn't explicitly differentiate from siblings like 'get_market_odds' or 'search_markets,' which might offer similar functionality, keeping it from a perfect score.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare it to sibling tools like 'get_market_odds' (which might fetch odds for a single market) or 'search_markets' (which might list markets without odds comparison). This lack of contextual direction limits its utility for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find price discrepancies across platforms
| Name | Required | Description | Default |
|---|---|---|---|
| min_spread | No | Minimum probability difference to report (default 0.05) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'find price discrepancies' but doesn't specify if this is a read-only operation, how it handles errors, rate limits, or what the output format looks like. This leaves significant gaps in understanding the tool's behavior.
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 description is a single, efficient sentence with zero waste, front-loaded with the core purpose. It's appropriately sized for the tool's complexity, earning full marks for conciseness.
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?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'price discrepancies' entail (e.g., returns arbitrage opportunities), how results are structured, or any behavioral traits, making it inadequate for a tool that likely involves complex financial data processing.
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?
The input schema has 100% description coverage, with 'min_spread' clearly documented. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 without compensating for any gaps.
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 clearly states the verb 'find' and the resource 'price discrepancies across platforms', which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'compare_platforms' or 'get_market_odds', which might have overlapping functionality, so it doesn't reach the highest score.
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?
The description provides no guidance on when to use this tool versus alternatives like 'compare_platforms' or 'search_markets'. It lacks context on prerequisites, such as needing market data from other tools, or exclusions, making it minimal in guiding agent selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current odds for a specific market
| Name | Required | Description | Default |
|---|---|---|---|
| platform | Yes | Platform name (manifold, polymarket, etc.) | |
| market_id | Yes | The market's native ID |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but doesn't add context on traits like whether this is a read-only operation, potential rate limits, authentication needs, or what the output looks like (e.g., format, freshness). This is a significant gap for a tool with no structured safety hints.
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 description is a single, efficient sentence with zero waste—it directly states the tool's purpose without redundancy or fluff. It's appropriately sized and front-loaded for quick understanding.
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?
Given the complexity (a data retrieval tool with no output schema and no annotations), the description is incomplete. It doesn't explain return values, error conditions, or behavioral traits, leaving the agent under-informed about how to interpret results or handle failures.
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 100%, so the schema already documents both parameters ('platform' and 'market_id') with clear descriptions. The description adds no additional meaning beyond implying these are needed to identify a market, which aligns with the schema. Baseline 3 is appropriate when the schema does the heavy lifting.
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 clearly states the verb ('Get') and resource ('current odds for a specific market'), making the purpose understandable. However, it doesn't distinguish this tool from potential siblings like 'search_markets' or 'get_tracked_markets' that might also retrieve odds-related data, so it misses full differentiation.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., real-time vs. historical odds), or exclusions, 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.
Get all markets in your watchlist with current prices
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves data ('Get all markets'), implying a read-only operation, but doesn't specify details like authentication needs, rate limits, response format, or whether it's paginated. For a tool with zero annotation coverage, this is a significant gap in transparency.
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 description is a single, efficient sentence: 'Get all markets in your watchlist with current prices.' It's front-loaded with the core action and resource, with no wasted words. Every part of the sentence contributes to understanding the tool's purpose.
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?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has gaps. It clearly states what the tool does but lacks behavioral details (e.g., response format, authentication) and usage guidelines. For a read operation with no structured data, it meets the minimum viable standard but could be more complete.
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?
The input schema has 0 parameters with 100% description coverage, so no parameters need documentation. The description doesn't add parameter details, which is acceptable since there are none. It implies the tool might rely on implicit context (e.g., user-specific watchlist), but this isn't a parameter issue. Baseline 4 is appropriate for zero parameters.
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 clearly states the tool's purpose: 'Get all markets in your watchlist with current prices.' It specifies the verb ('Get'), resource ('markets in your watchlist'), and scope ('with current prices'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'search_markets' or 'track_market,' which might have overlapping functions.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a watchlist), exclusions, or comparisons to siblings like 'search_markets' (which might filter markets) or 'track_market' (which might add to a watchlist). This lack of context leaves the agent to infer usage based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available market categories
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states the basic action without disclosing behavioral traits such as permissions needed, rate limits, pagination, or what 'available' means. It lacks details on safety, performance, or response format.
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 description is a single, efficient sentence with no wasted words, clearly front-loaded with the tool's purpose. It's appropriately sized for a simple listing tool.
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?
Given no annotations, no output schema, and a simple tool with 0 parameters, the description is incomplete—it doesn't explain what 'available' entails, how results are returned, or any constraints. More context is needed for effective use by an AI agent.
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?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter semantics, but this is acceptable given the lack of inputs, aligning with the baseline for zero parameters.
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 'List available market categories' clearly states the action (list) and resource (market categories), but it's vague about scope and doesn't distinguish from sibling tools like 'browse_category' or 'get_tracked_markets'. It avoids tautology but lacks specificity.
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?
No guidance is provided on when to use this tool versus alternatives like 'browse_category' or 'search_markets'. The description implies a general listing function but offers no context, prerequisites, or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for prediction markets across platforms
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (e.g., 'Will Trump win 2024?') | |
| platforms | No | Optional: filter to specific platforms |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It states the action ('search') but doesn't cover critical traits like whether this is a read-only operation, if it requires authentication, rate limits, pagination, or what the search scope entails (e.g., real-time vs. historical). This is a significant gap for a tool with no annotation coverage.
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 description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it highly concise and well-structured for quick understanding.
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?
Given the complexity of a search tool with no annotations and no output schema, the description is incomplete. It doesn't explain return values, error handling, or behavioral nuances, leaving the agent under-informed about how to interpret results or handle edge cases.
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 100%, so the schema already documents both parameters ('query' and 'platforms') with descriptions. The description adds no additional meaning beyond implying a cross-platform search, which is redundant with the schema. Baseline 3 is appropriate when the schema does the heavy lifting.
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 clearly states the verb ('search') and resource ('prediction markets across platforms'), providing a specific purpose. However, it doesn't explicitly differentiate from sibling tools like 'browse_category' or 'get_tracked_markets', which might also involve market discovery, so it lacks sibling differentiation for a perfect score.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare to siblings like 'browse_category' for categorical browsing or 'get_tracked_markets' for retrieving saved markets, leaving the agent without usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add a market to your tracking watchlist
| Name | Required | Description | Default |
|---|---|---|---|
| platform | Yes | Platform name (manifold, polymarket, etc.) | |
| market_id | Yes | The market's native ID | |
| alias | No | Optional friendly name for the market |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a write operation ('Add'), but doesn't specify if this requires authentication, has side effects (e.g., duplicates), rate limits, or what happens on success/failure. This is inadequate for a mutation tool with zero annotation coverage.
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 description is a single, direct sentence with zero wasted words. It's appropriately sized and front-loaded, clearly stating the tool's core function without unnecessary elaboration.
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?
Given the tool's complexity (a mutation with 3 parameters) and lack of annotations or output schema, the description is incomplete. It doesn't explain behavioral aspects like permissions, error handling, or return values, leaving significant gaps for an agent to use it effectively.
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?
The schema description coverage is 100%, so the schema already documents all parameters (platform, market_id, alias). The description adds no additional meaning beyond implying these parameters are used to identify and optionally name a market for tracking, which is minimal value over the schema.
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 clearly states the action ('Add') and resource ('a market to your tracking watchlist'), making the purpose understandable. However, it doesn't differentiate this tool from sibling tools like 'get_tracked_markets' or 'search_markets' beyond the basic verb, leaving some ambiguity about its specific role in the toolset.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a watchlist), exclusions, or comparisons to siblings like 'get_tracked_markets' (for viewing) or 'search_markets' (for finding), leaving the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.1browse_categorycompare_platformsfind_arbitrageget_market_oddsget_tracked_marketslist_categoriessearch_marketstrack_marketEach tool has a clearly distinct purpose with no ambiguity. For example, 'browse_category' focuses on category-specific browsing, 'search_markets' handles cross-platform search, and 'get_market_odds' retrieves specific market data, ensuring agents can easily differentiate between them.
All tool names follow a consistent verb_noun pattern using snake_case, such as 'browse_category', 'compare_platforms', and 'track_market'. This uniformity makes the tool set predictable and easy to navigate for agents.
With 8 tools, the server is well-scoped for predictive market analysis, covering key operations like browsing, searching, comparing, and tracking. Each tool earns its place without feeling excessive or insufficient for the domain.
The tool set provides strong coverage for core workflows, including market discovery, comparison, and tracking. A minor gap exists in direct market interaction tools, such as placing bets or managing user accounts, but agents can still perform essential analysis tasks effectively.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Live Kalshi + Polymarket prediction-market data and cross-venue arbitrage spreads, one schema.
Polymarket, Manifold, Metaculus compared: one fair probability per question. No API key needed.
Live prediction markets: Polymarket + Kalshi prices, odds, order books. Pay-per-call USDC, no key.
Live Kalshi and Polymarket data: EV edges, cross-venue arbitrage, markets, and whale trades.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/EricGrill/mcp-predictive-market'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
