{
  "markdown": "# kalshi-mcp-server\n\n<!-- mcp-name: io.github.cejor6/kalshi-mcp-server -->\n\n[![PyPI](https://img.shields.io/pypi/v/kalshi-mcp-server.svg)](https://pypi.org/project/kalshi-mcp-server/)\n[![CI](https://github.com/cejor6/kalshi-mcp-server/actions/workflows/ci.yml/badge.svg)](https://github.com/cejor6/kalshi-mcp-server/actions/workflows/ci.yml)\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)\n[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](pyproject.toml)\n[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)\n\n📦 **[PyPI](https://pypi.org/project/kalshi-mcp-server/)** &nbsp;·&nbsp;\n🗂️ **[MCP Registry](https://registry.modelcontextprotocol.io/?search=io.github.cejor6/kalshi-mcp-server)** &nbsp;·&nbsp;\n🐳 **[Container image](https://github.com/cejor6/kalshi-mcp-server/pkgs/container/kalshi-mcp-server)** &nbsp;·&nbsp;\n🚀 **[Deploy guide](DEPLOY.md)**\n\nA Model Context Protocol server for [Kalshi](https://kalshi.com)\nprediction markets. Native RSA-PSS auth, async token-bucket rate\nlimiting, two-step prepare/confirm order flow with safety caps,\noptional bundled OAuth proxy for remote-MCP deployments, 26 tools +\n4 resources across REST and WebSocket. MIT, designed to be forked.\n\nWorks with any [MCP](https://modelcontextprotocol.io) client —\nlocally via stdio (Claude Desktop, Claude Code, Cursor, Zed,\nContinue, Cline, Goose, etc.) or remotely as a self-hosted HTTP\nserver (claude.ai custom connectors today, any OAuth-capable MCP\nclient in the future).\n\n> ⚠️ **This software lets an LLM place trades. Read [DISCLAIMER.md](DISCLAIMER.md)\n> before deploying.** Trading prediction markets involves substantial\n> risk of loss. AI agents make mistakes — sometimes confidently. The\n> authors are not liable for any losses. Test in demo (`KALSHI_ENV=demo`,\n> `KALSHI_TRADING_ENABLED=0`) until you understand the failure modes.\n\n> **Status — alpha.** Auth (REST + WS), rate limiting, safety controls,\n> 26 tools across REST + live channels, and 4 resources are in place.\n> A long-lived multiplexed WebSocket session and `kalshi://markets/{ticker}/orderbook`\n> live resource are planned for v0.2.\n\n---\n\n## Quickstart (30 seconds)\n\nRead-only against Kalshi's **demo** environment — no real money, no trading\nflag. This is the safe way to try it.\n\n```bash\npipx install kalshi-mcp-server        # or: pip install kalshi-mcp-server\n```\n\nPoint any MCP client at it (this is the Claude Desktop / Claude Code shape —\nsee the [full client matrix](#where-to-put-this-config) for others):\n\n```json\n{\n  \"mcpServers\": {\n    \"kalshi\": {\n      \"command\": \"kalshi-mcp\",\n      \"args\": [\"--env-file\", \"/Users/you/.kalshi/.env\"]\n    }\n  }\n}\n```\n\nMinimal `~/.kalshi/.env` (get a demo key at\n[demo.kalshi.co](https://demo.kalshi.co/account/profile) — it's shown once):\n\n```env\nKALSHI_API_KEY_ID=<your-demo-key-id>\nKALSHI_PRIVATE_KEY_PATH=/absolute/path/to/demo_private_key.pem\nKALSHI_ENV=demo\n```\n\nRestart the client and ask it to run a Kalshi tool. Enabling **prod** and\n**trading** is a deliberate opt-in — a few more flags (`KALSHI_ALLOW_PROD=1`,\n`KALSHI_TRADING_ENABLED=1`) — see [Configure](#configure) and the\n[safety model](#safety-model).\n\n### What a call looks like\n\nAsk the agent for tradeable markets and `kalshi_find_liquid_markets` returns a\nvolume-ranked, combo-excluded shortlist (trimmed, illustrative):\n\n```json\n{\n  \"scanned\": 300,\n  \"markets\": [\n    {\n      \"ticker\": \"KXNBAGAME-25JUL12BOSLAL-BOS\",\n      \"title\": \"Will the Celtics beat the Lakers?\",\n      \"yes_bid_dollars\": 0.58, \"yes_ask_dollars\": 0.60,\n      \"volume_24h_fp\": 41230, \"open_interest_fp\": 88400,\n      \"status\": \"active\", \"close_time\": \"2026-07-12T23:30:00Z\"\n    },\n    {\n      \"ticker\": \"KXHIGHNY-26JUL12-B90.5\",\n      \"title\": \"Will NYC's high temp exceed 90.5°F today?\",\n      \"yes_bid_dollars\": 0.31, \"yes_ask_dollars\": 0.34,\n      \"volume_24h_fp\": 12760, \"open_interest_fp\": 23110,\n      \"status\": \"active\", \"close_time\": \"2026-07-13T04:00:00Z\"\n    }\n  ]\n}\n```\n\nPlacing a trade is a deliberate two step — `kalshi_prepare_order` runs the\nlocal safety checks and hands back a `confirmation_id`; nothing reaches Kalshi\nuntil you call `kalshi_confirm_order` with that token. An LLM can't place an\norder in a single call.\n\n---\n\n## Why this server\n\nMost existing Kalshi MCPs are thin wrappers around a handful of REST\nendpoints. This one aims to be:\n\n- **Native Kalshi.** Real RSA-PSS signer that handles the gotchas\n  (path-without-query-string, ms timestamps, separate demo/prod keys).\n- **Rate-limit aware.** Client-side token bucket mirrors Kalshi's 2026\n  read/write budget model, so the server can't spam the API into a 429.\n- **Safe by default.** Refuses to start against prod without an explicit\n  opt-in flag. Refuses to write without a separate trading-enabled flag.\n  Order-time controls (size cap, daily cap, cash reserve) are all\n  operator-configurable.\n- **Hosted-deploy friendly.** Accepts the private key as either a file\n  path OR an env var with inline PEM, so it works on platforms without\n  filesystem mounts.\n- **Fork-able.** MIT, no personal data, CI/CD set up so PR contributions\n  flow through `main` without ever triggering a production deploy — only\n  tagged releases (`v*`) do. Your fork's deployment stays decoupled from\n  this repo's, and your fork's contributors can't affect what you run.\n\n## Install\n\n### From PyPI (recommended)\n\nPublished as [`kalshi-mcp-server`](https://pypi.org/project/kalshi-mcp-server/).\n[pipx](https://pipx.pypa.io/) installs the `kalshi-mcp` entrypoint into its own\nisolated environment:\n\n```bash\npipx install kalshi-mcp-server        # or: pip install kalshi-mcp-server\n```\n\n### From source\n\n```bash\ngit clone https://github.com/cejor6/kalshi-mcp-server.git\ncd kalshi-mcp-server\nuv sync\n```\n\n### Docker\n\nMulti-arch (`amd64` + `arm64`) images are published to GHCR on every tagged\nrelease, tagged `:latest` and `:vX.Y.Z`:\n\n```bash\ndocker pull ghcr.io/cejor6/kalshi-mcp-server:latest\n```\n\nSee [DEPLOY.md](DEPLOY.md) for hosted deployment.\n\n## Configure\n\n1. Generate a Kalshi API key at https://kalshi.com/account/profile (or\n   the demo equivalent at https://demo.kalshi.co/account/profile). Save\n   the private key — it is shown ONCE.\n\n2. Put your secrets in **one** `.env` file. A good location for the\n   MCP-client use case is `~/.kalshi/.env` (outside any repo). For local\n   dev, the repo's own `.env` (gitignored) works too.\n\n```bash\ncp .env.example ~/.kalshi/.env\n# edit ~/.kalshi/.env\n```\n\n3. At minimum, set:\n\n```env\nKALSHI_API_KEY_ID=<your-key-id>\nKALSHI_PRIVATE_KEY_PATH=/absolute/path/to/your_kalshi_private_key.pem\nKALSHI_ENV=demo\n```\n\nFor prod, also set:\n\n```env\nKALSHI_ENV=prod\nKALSHI_ALLOW_PROD=1\nKALSHI_TRADING_ENABLED=1   # only if you want writes\n```\n\n### How env vars are resolved\n\nOn startup, the server resolves config in this order (highest wins):\n\n1. **Values already in the process environment** — set in the MCP client\n   config's `env:` block, or exported in your shell.\n2. **`.env` file** — loaded from `--env-file PATH` if you pass that flag,\n   otherwise from `./.env` in the current working directory if it exists.\n   Variables already in the environment from step 1 are **not** overridden.\n\nSo you can put secrets either inline in the MCP config (`env:`) or in a\nfile the config points at (`--env-file`). You don't need to do both.\n\n## Use with an MCP client (stdio)\n\nEvery MCP stdio client uses the same shape: a `command` to launch the\nserver, optional `args`, optional `env`. The differences are just the\nfile/UI where you put the config.\n\nThree install patterns work — pick whichever fits your environment.\n\n### Pattern A — `pipx install` (cleanest, recommended)\n\nInstalls `kalshi-mcp` to a globally-available, isolated environment.\n[pipx](https://pipx.pypa.io/) is the modern Python tool for this:\n\n```bash\npipx install kalshi-mcp-server\n```\n\nMCP client config then collapses to:\n\n```json\n{\n  \"mcpServers\": {\n    \"kalshi\": {\n      \"command\": \"kalshi-mcp\",\n      \"args\": [\"--env-file\", \"/Users/you/.kalshi/.env\"]\n    }\n  }\n}\n```\n\nUpdate with `pipx upgrade kalshi-mcp-server` when you want the latest.\n\n### Pattern B — `uv run` against a local clone\n\nBest if you've cloned the repo and have [uv](https://docs.astral.sh/uv/)\ninstalled. Point the MCP client at `uv` with `--directory`:\n\n```json\n{\n  \"mcpServers\": {\n    \"kalshi\": {\n      \"command\": \"uv\",\n      \"args\": [\n        \"run\",\n        \"--directory\", \"/absolute/path/to/kalshi-mcp-server\",\n        \"kalshi-mcp\",\n        \"--env-file\", \"/Users/you/.kalshi/.env\"\n      ]\n    }\n  }\n}\n```\n\n`uv run` activates the project's venv automatically. Update with\n`git pull` + restart the MCP client. Useful for development /\nhacking on the server itself.\n\n### Pattern C — Docker against the public image\n\nBest for users without Python installed, or who prefer container\nisolation:\n\n```json\n{\n  \"mcpServers\": {\n    \"kalshi\": {\n      \"command\": \"docker\",\n      \"args\": [\n        \"run\", \"--rm\", \"-i\",\n        \"-v\", \"/Users/you/.kalshi/demo.pem:/secrets/demo.pem:ro\",\n        \"-e\", \"KALSHI_API_KEY_ID=<your-key-id>\",\n        \"-e\", \"KALSHI_PRIVATE_KEY_PATH=/secrets/demo.pem\",\n        \"-e\", \"KALSHI_ENV=demo\",\n        \"ghcr.io/cejor6/kalshi-mcp-server:latest\"\n      ]\n    }\n  }\n}\n```\n\nThe `-v` mount bind-mounts your PEM file read-only into the\ncontainer; `KALSHI_PRIVATE_KEY_PATH` points at that path. Secrets\nlive in the JSON config — fine for a single-user machine.\n\n### Where to put this config:\n\n| Client | Config location |\n|---|---|\n| [Claude Desktop](https://claude.ai/download) | `claude_desktop_config.json` (Settings → Developer) |\n| [Claude Code](https://claude.com/claude-code) | project `.mcp.json` or `~/.claude/mcp.json` |\n| [Cursor](https://cursor.com) | Settings → MCP → Add new MCP Server (UI fills the same JSON) |\n| [Zed](https://zed.dev) | `~/.config/zed/settings.json` under `context_servers` |\n| [Continue](https://continue.dev) | `~/.continue/config.json` under `experimental.modelContextProtocolServers` |\n| [Cline](https://cline.bot) | Cline settings → MCP Servers → Edit JSON |\n| [Goose](https://block.github.io/goose/) | `~/.config/goose/config.yaml` under `extensions` |\n\nIf you'd rather inline secrets in the MCP config (acceptable for\nlocal dev where the config file is on your own machine):\n\n```json\n{\n  \"mcpServers\": {\n    \"kalshi\": {\n      \"command\": \"kalshi-mcp\",\n      \"env\": {\n        \"KALSHI_API_KEY_ID\": \"your-key-id\",\n        \"KALSHI_PRIVATE_KEY_PATH\": \"/path/to/your/private_key.pem\",\n        \"KALSHI_ENV\": \"demo\"\n      }\n    }\n  }\n}\n```\n\n> **Why not just `.env` in the project dir?** MCP clients spawn the\n> server as a subprocess from their own working directory (typically\n> your home dir on macOS/Linux, the client's install dir on Windows),\n> so a `.env` sitting in this repo wouldn't get found. Hence\n> `--env-file` to point at it explicitly. Running the server directly\n> from the project dir (no client) still works without flags — the\n> CLI auto-loads `./.env` when launched there.\n\n## Use as a remote MCP service\n\nFor clients that don't speak local stdio — currently the main one\nbeing **claude.ai's custom connector form**, which only supports\nOAuth-protected HTTP — host the server somewhere reachable and point\nthe client at it. The OAuth proxy is bundled with the server; you\njust need to configure it.\n\nSee [DEPLOY.md](DEPLOY.md) for an end-to-end walkthrough using\nRender + GitHub OAuth + Upstash Redis. Other image-deploy hosts\n(Fly.io, Cloud Run, ECS, Railway) work the same way — Render is just\nthe worked example.\n\n## Tools\n\n| Group | Tools |\n|---|---|\n| Exchange / account | `kalshi_get_exchange_status`, `kalshi_get_exchange_schedule`, `kalshi_get_api_limits`, `kalshi_get_environment`, `kalshi_set_safety_limits` |\n| Discovery | `kalshi_get_markets`, `kalshi_find_liquid_markets`, `kalshi_get_market`, `kalshi_get_event`, `kalshi_get_events`, `kalshi_get_series`, `kalshi_get_series_list`, `kalshi_get_series_summary`, `kalshi_get_milestones`, `kalshi_get_trades` |\n| Market data | `kalshi_get_orderbook`, `kalshi_get_orderbooks`, `kalshi_get_market_candlesticks`, `kalshi_get_event_candlesticks`, `kalshi_get_batch_candlesticks`, `kalshi_get_event_forecast_history`, `kalshi_get_market_trades` |\n| Combos / parlays | `kalshi_get_combo_collections`, `kalshi_get_combo_collection`, `kalshi_get_combo_events`, `kalshi_get_combo_legs`, `kalshi_create_combo_market` (write — off by default, see below) |\n| Portfolio | `kalshi_get_balance`, `kalshi_get_positions`, `kalshi_get_orders`, `kalshi_get_fills`, `kalshi_get_settlements` |\n| Orders (write) | `kalshi_prepare_order`, `kalshi_confirm_order`, `kalshi_cancel_order`, `kalshi_decrease_order`, `kalshi_get_order` |\n| Live (WebSocket) | `kalshi_get_live_orderbook`, `kalshi_sample_trades` |\n| External data (read-only) | `kalshi_fetch_external_data` — host-allowlisted, GET-only, https-only fetch of public data feeds (Polymarket gamma/clob, NWS `api.weather.gov`, Open-Meteo incl. ensemble, Tennis Abstract, Deribit public). No credentials attached (`trust_env=False`), redirects not followed, body size- and wall-clock-capped and returned wrapped in UNTRUSTED-EXTERNAL-DATA delimiters. Exists so clients whose own egress is restricted (e.g. claude.ai cloud routines) can reach the public feeds their read-only research needs; the allowlist is enforced at runtime, additions are a code change, and the boundary rationale lives in AGENTS.md. |\n\nWrite tools require `KALSHI_TRADING_ENABLED=1`. `kalshi_prepare_order` runs\nlocal safety checks and returns a `confirmation_id`; nothing is sent to\nKalshi until you call `kalshi_confirm_order` with that token. Cancel and\ndecrease bypass the trading-enabled flag — they only reduce exposure.\n\n**Listing markets for an LLM:** `kalshi_get_markets` / `kalshi_get_market`\naccept `minimal=true` to project each market down to a small whitelist of\ntriage fields (ticker, prices, sizes, volume, status, close time). Prefer\nthis over `compact=true` for scanning — `compact` is a blacklist and barely\nshrinks multivariate (`KXMVE…`) combo markets, whose bulk lives in\n`custom_strike` / `mve_selected_legs` / long sub-titles. Pass a custom\n`fields=\"ticker,yes_bid_dollars,…\"` to override the default whitelist.\nView precedence is `fields` > `minimal` > `compact` > full. `kalshi_get_event`\n/ `kalshi_get_events` accept the same `minimal` / `fields` for their nested\nmarkets (the event objects themselves only have the `compact` view).\n\n**Don't gate on `liquidity_dollars`:** Kalshi currently returns it as\n`0.0000` on every market, even deep books — measure liquidity from the\norderbook (best bid/ask + resting size) plus `volume_24h_fp` /\n`open_interest_fp`. It is stripped from `compact` and `minimal` views.\n\n**Finding tradeable markets:** the default open listing is dominated by\nmultivariate (`KXMVE…`) combo markets with empty/one-sided books. Pass\n`mve_filter=\"exclude\"` to `kalshi_get_markets` to drop them server-side, or\nuse `kalshi_find_liquid_markets` — it excludes combos, ranks by 24h volume,\nand returns a short minimal-projection shortlist. (Kalshi has no server-side\nsort, so the helper's ranking is over a bounded scan window, reported as\n`scanned` in the result.) Pass `scan_all=true` to sweep the FULL open listing\nbefore ranking — that turns the shortlist into a genuine exchange-wide top-N\nrather than the top of an arbitrary slice. The sweep is bounded by internal\nrequest / wall-clock / market caps, and the result reports `complete` plus\n`stopped_by` so a partial scan is never mistaken for an exhaustive one.\n\n**Scanning wide without burning context:** three tools exist for\nscan/anomaly workloads that would otherwise cost one call per market.\n\n- `kalshi_get_orderbooks(tickers=[…], depth=5)` fetches up to 25 books in\n  one request, with per-ticker error isolation — a bad or event-level\n  ticker becomes an `error` entry for that ticker instead of failing the\n  batch. Kalshi's batch endpoint has no `depth` parameter, so depth is\n  applied server-side by this MCP; it keeps the *best* levels (Kalshi\n  returns levels ascending by price and both sides are bids).\n- `kalshi_get_series_summary()` rolls the whole listing up to one row per\n  series (market count, event count, 24h volume, tightest spread, soonest\n  close). Cheap in context, not free in reads — it's the daily \"new supply\n  census\" that spots a new event class listing without paging thousands of\n  markets. Note `series_ticker` is *derived* from the ticker prefix: Kalshi\n  does not return it on market objects.\n- `kalshi_get_batch_candlesticks(market_tickers=[…])` fetches OHLC bars for\n  up to 100 markets in one request — a momentum lens over a whole shortlist.\n  Its budget shape differs from the single-market tool: Kalshi returns at\n  most 10,000 candles *total across all tickers*, so window cost multiplies\n  by ticker count. Validated locally, with a message naming how many markets\n  the requested window actually affords.\n\n**Combos / parlays.** The multivariate surface lives in its own module:\n\n- `kalshi_get_combo_collections` / `kalshi_get_combo_collection` — the parlay\n  *families* on offer and the rules each imposes (`size_min` / `size_max`\n  legs, `is_all_yes`, the eligible-event universe).\n- `kalshi_get_combo_events` — combos already listed against a collection, i.e.\n  live parlay supply. Defaults `minimal=True` for nested markets, because\n  combo markets are the largest objects Kalshi returns.\n- `kalshi_get_combo_legs(ticker)` resolves a `KXMVE…` combo into its\n  underlying legs (market ticker, side, title) from `mve_selected_legs` —\n  strictly better than splitting the combo's title string on commas, which\n  drops the leg tickers and mis-splits on titles that contain a comma. If\n  Kalshi published no leg breakdown, it returns a structured\n  `resolvable: false` rather than guessing. The `legs` it returns feed\n  straight back into the create tool, so you can round-trip an existing combo\n  and vary one leg.\n- `kalshi_create_combo_market` — **write.** Materializes a combo market\n  ticker for a chosen leg set. It places no order and commits no money, so it\n  has its own gate rather than riding on `KALSHI_TRADING_ENABLED`: set\n  `MCP_ALLOW_COMBO_CREATION=1` to register it at all (default off, and when\n  off the tool isn't advertised to the model). Kalshi allows 5000 creations\n  per **week** per account, so the server also enforces\n  `MCP_MAX_COMBO_CREATIONS_PER_DAY` (default 100, in-process, resets at UTC\n  midnight and on restart) to stop a retry loop burning the weekly quota.\n  Before the POST it pre-flights your leg set against the collection's own\n  `size_min`/`size_max`/`is_all_yes` rules, which Kalshi otherwise rejects\n  with an opaque 400; that check fails open if the collection can't be read.\n\nTwo env vars come with the combo write surface — add them to your `.env`:\n\n```bash\nMCP_ALLOW_COMBO_CREATION=0        # 1 registers kalshi_create_combo_market\nMCP_MAX_COMBO_CREATIONS_PER_DAY=100\n```\n\n**Event ticker vs market ticker:** a *market* ticker carries an outcome\nsuffix (`…PITHOU-HOU`); an *event* ticker (`…PITHOU`) does not. Passing an\nevent ticker to `kalshi_get_market` / `kalshi_get_orderbook` / `kalshi_get_markets`\nused to fail silently (404, or an empty book/list read as \"no liquidity\").\nThese tools now detect that case and raise an actionable hint naming the\nreal market tickers instead.\n\n## Resources\n\n| URI | Description |\n|---|---|\n| `kalshi://environment` | Current env, safety limits in force + their env ceilings, rate-limit headroom (no API call) |\n| `kalshi://balance` | Cash + buying power |\n| `kalshi://positions` | Open positions (unsettled) |\n| `kalshi://orders` | Resting orders (open / partially filled) |\n\nA WebSocket-backed live-orderbook resource (`kalshi://markets/{ticker}/orderbook`)\nis planned — for now, use the `kalshi_get_live_orderbook` tool which\nopens a transient WS, samples the book, and returns the current\nsnapshot + delta arrival rate.\n\n## Safety model\n\nThis server is deliberately conservative for the same reason your bank's\nATM is — small mistakes shouldn't cost large amounts.\n\n- `KALSHI_ENV=prod` **requires** `KALSHI_ALLOW_PROD=1`. The server\n  refuses to start without both.\n- All write tools require `KALSHI_TRADING_ENABLED=1`. The default is\n  read-only.\n- Per-order caps (`MCP_MAX_ORDER_SIZE_USD`, `MCP_DAILY_LIMIT_USD`,\n  `MCP_MAX_CONTRACTS_PER_ORDER`, `MCP_CASH_RESERVE_USD`) are checked\n  before the request reaches Kalshi.\n- **Tighten limits at runtime, no redeploy.** Those env vars are the hard\n  *ceiling*. The `kalshi_set_safety_limits` tool can tighten any limit\n  on a running server (e.g. a fast clamp-down) but can **never loosen one\n  past its env ceiling** — the three caps only go down, the cash reserve\n  only goes up. Raising a ceiling still requires changing the env var and\n  redeploying. The limits in force vs. their ceilings show up in\n  `kalshi_get_environment` and `kalshi://environment`. Set `MCP_REDIS_URL`\n  to make runtime changes survive a restart (otherwise they reset to the\n  env ceilings on reboot).\n\nSee [AGENTS.md](AGENTS.md) for the full design.\n\n## Deployment\n\nUse it locally as a stdio server with any MCP client, or run it as a\nremote HTTP MCP behind an OAuth proxy.\n\nFor remote deployment, the recommended setup is **image-deploy**: a\nproduction host (Render, Fly.io, Cloud Run, ECS, anything that supports\npulling container images) pulls the image that's built and pushed when\nyou tag a release (`git tag v0.1.0`). This decouples deployments from\nPR merges — PRs to `main` only ever run tests, never push a new image —\nso a malicious or careless PR cannot affect what's running in your\ncontainer.\n\nSee [DEPLOY.md](DEPLOY.md) for the rationale and a worked example with\nRender.\n\n## Contributing\n\nPRs welcome. Read [CONTRIBUTING.md](CONTRIBUTING.md) first — there are a\nfew rules around auth changes, secret hygiene, and test conventions.\n\n## License\n\n[MIT](LICENSE). See also [DISCLAIMER.md](DISCLAIMER.md) — the MIT\nlicense disclaims warranty; DISCLAIMER.md spells out the trading- and\nAI-specific risks you're accepting by using this software.\n\n## Acknowledgments\n\n- [FastMCP](https://github.com/jlowin/fastmcp) — MCP framework.\n- [Kalshi](https://docs.kalshi.com) — the underlying API.\n",
  "bytes": 22290,
  "sha": "e32ec431311bc29b53b9e66d03c826f609b8b3cda3684a97c2b0a2ed2a6390b4",
  "repo_slug": "cejor6/kalshi-mcp-server",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/mcp_io_github_cejor6_kalshi_mcp_server_0a79a92b/readme"
}