The Konseki MCP server provides AI agents with access to pre-computed historical market context data for global equities via the Konseki public API, acting as a direct wrapper that returns raw JSON without interpretation.
Fetch metadata (get_konseki_metadata): Retrieve raw metadata JSON from the Konseki API, including available countries and configuration details. No input parameters required.
List supported symbols (list_konseki_symbols): Retrieve a raw list of supported equity symbols available through the Konseki API. No input parameters required.
Get market analysis (get_konseki_analysis): Fetch raw historical market context analysis for a specific stock by providing the symbol (e.g., "AAPL"), exchange (e.g., "NASDAQ"), and lookback period. Supported lookback values: 5, 10, 15, 20, 25, 30, 40, or 50 days. Returns historical analogs, pattern-match data, outcome distributions, and match-quality scores.
All tools return raw JSON directly from the Konseki public API — the client or downstream application is responsible for interpreting the data.
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., "@Konseki MCP Show me market context for AAPL on NASDAQ with 15 days lookback"
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.
Official Model Context Protocol server for Konseki.
Konseki is a pre-computed historical market context API for global equities, built for AI trading and quants. It matches current market conditions against historical analogs and returns structured pattern-match data, outcome distributions, and match-quality scores, grounding an AI agent's reasoning in evidence rather than generic commentary.
Konseki MCP is a direct wrapper around the Konseki public API. It lets AI agents and AI trading tools call Konseki endpoints through MCP tools while preserving the raw API response JSON for the user or downstream application to interpret.
Published package: @konseki/mcp
Node.js 20 or newer.
A Konseki API key.
Get an API key from konseki.io.
Related MCP server: Polymarket MCP
Direct API wrapper: the MCP server fetches Konseki API responses and returns them without interpretation.
User-owned interpretation: users, builders, and downstream AI clients decide how to analyze or summarize the returned JSON.
Public API only: the server uses X-API-Key against documented Konseki endpoints.
No internal credentials: non-public service or operational credentials are never required for this package.
The server reads configuration from environment variables:
KONSEKI_API_KEY=ks_live_your_api_keyDo not commit real API keys.
AI client
|
v
Konseki MCP server
|
v
Konseki public API
|
v
Raw historical market context JSONThe MCP server should not bypass Konseki public API behavior. It should behave like any other public API client.
get_konseki_metadataFetches raw JSON from GET /v1/metadata?country={country}.
Input:
{
"country": "US"
}list_konseki_countriesFetches raw JSON from GET /v1/countries.
Input: none.
list_konseki_symbolsFetches raw JSON from GET /v1/symbols?country={country}.
Input:
{
"country": "US"
}get_konseki_analysisFetches raw JSON from GET /v1/analysis/{symbol}-{exchange}?country={country}&lookback={lookback}.
Input:
{
"country": "US",
"symbol": "AAPL",
"exchange": "NASDAQ",
"lookback": 15
}Supported lookback values: 5, 10, 15, 20, 25, 30, 40, 50.
The server requests gzip-compressed API responses and decompresses them locally before returning JSON to the MCP client. This is handled automatically; users do not need to configure compression.
Use the published npm package through an MCP client with npx:
{
"mcpServers": {
"konseki": {
"command": "npx",
"args": ["-y", "@konseki/mcp"],
"env": {
"KONSEKI_API_KEY": "ks_live_your_api_key"
}
}
}
}This is the recommended configuration for users who want the official released package from npm.
For development from this checkout, install dependencies, build the package, and configure your MCP client to run the built server:
npm install
npm run build{
"mcpServers": {
"konseki": {
"command": "node",
"args": ["/absolute/path/to/konseki-mcp/dist/index.js"],
"env": {
"KONSEKI_API_KEY": "ks_live_your_api_key"
}
}
}
}Install dependencies:
npm installRun verification:
npm run typecheck
npm test
npm run buildNever commit real API keys.
Never log raw API keys.
Never include user credentials in test snapshots or examples.
Use fake keys in documentation and tests.
Fetch raw analysis JSON for a symbol, exchange, and lookback from the Konseki public API.
| Name | Required | Description | Default |
|---|---|---|---|
| symbol | Yes | ||
| exchange | Yes | ||
| lookback | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must bear the full burden. It only states 'Fetch raw analysis JSON' but does not disclose behavioral traits such as whether the operation is read-only, destructive, requires authentication, or has rate limits. No additional behavioral context beyond the basic purpose.
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 clear sentence with no extraneous text. It is efficiently front-loaded, though it could benefit from additional structure (e.g., noted parameter details).
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 insufficient. It does not explain the return format, error conditions, or provide examples. For a tool with three required parameters and no additional metadata, more context is needed 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 description mentions the three parameters (symbol, exchange, lookback) but does not explain their meaning, constraints, or examples. The schema lacks descriptions (0% coverage), and the description adds minimal semantic value beyond naming the 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 'Fetch raw analysis JSON for a symbol, exchange, and lookback', specifying the verb, resource, and key parameters. It distinguishes from sibling tools 'get_konseki_metadata' and 'list_konseki_symbols' by focusing on raw analysis data.
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 on when to use this tool versus alternatives. The description does not mention the sibling tools or provide any context about when to prefer this over get_konseki_metadata or list_konseki_symbols.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch raw metadata JSON from the Konseki public API.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description does not disclose any behavioral traits such as authentication needs, rate limits, or side effects. With no annotations, the description carries the full burden but provides minimal 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 sentence with no wasted words. It is appropriately concise for a parameter-free tool, though it could be slightly more informative.
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 parameters, no output schema, and no annotations, the description lacks detail about the metadata content, potential authentication requirements, or how to handle the response. The tool is simple but the description is incomplete for an agent to fully understand its 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?
The input schema has no parameters, and the description adds no additional meaning beyond the schema. Coverage is 100%, so a 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 it fetches raw metadata JSON from the Konseki public API, using a specific verb and resource. It distinguishes from siblings like get_konseki_analysis and list_konseki_symbols by indicating it returns raw metadata.
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 its siblings. There is no mention of use cases or alternatives, leaving the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch raw supported symbols JSON from the Konseki public API.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses it fetches raw JSON, which is sufficient for a simple read operation. No annotations exist, but the description clearly communicates the action and output format. Could mention if it's cached or has rate limits, but not required.
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?
Single, front-loaded sentence that covers the essential information without padding. Every word adds value.
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 output schema, the description specifies the returned content ('symbols JSON') which is adequate for a simple list endpoint. Could include example or more detail, but sufficient for tool selection.
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?
No parameters; schema coverage is 100% (trivially). Description doesn't need to add parameter details, so baseline 4 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?
Clearly states it fetches raw supported symbols JSON from the Konseki public API. The verb 'Fetch' combined with 'list' indicates a read operation, and it distinguishes from siblings like get_konseki_analysis and get_konseki_metadata.
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?
Lacks explicit guidance on when to use this tool over alternatives. The description implies it's for listing symbols, but no direct comparison with siblings or note on prerequisites.
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.
v1.0.3get_konseki_analysisget_konseki_metadatalist_konseki_symbolsEach tool targets a distinct data type: analysis data, metadata, and supported symbols. There is no overlap in their purposes, making it clear which tool to use for a given retrieval task.
All tool names follow a consistent verb_noun_konseki pattern: 'get_konseki_analysis', 'get_konseki_metadata', and 'list_konseki_symbols'. The use of 'get' for single items and 'list' for collections is appropriate and predictable.
With 3 tools, the server is slightly on the low end but still well-scoped for a focused API wrapper that provides read-only access to three core data types. Each tool serves a clear purpose without unnecessary bloat.
The tools cover the main retrieval operations for the Konseki API: analysis, metadata, and symbol listing. Minor gaps might include filtering or parameterized queries, but the set is complete for basic data access needs.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Pre-computed market data that improves agent reasoning, reduces token usage, and replaces pipelines.
Live multi-asset market data for AI agents with provenance, starter credits, x402, and examples.
Market intelligence for AI agents. Real-time data, cross-market analysis, and regime detection.
Market data and web intelligence for AI agents, paid per call in USDC on Base via x402.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/konseki-official/konseki-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
