Koskamo

Hokmah MCP

An MCP server that provides AI coding agents with persistent architectural memory of codebases via TransitionGraph, IdeaGraph, and WorldModel. It enables impact analysis, test generation, and code writing by traversing a graph instead of sending entire codebases to LLMs.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Hokmah MCP logo, by Catalyst AI ResearchCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-07Published by Catalyst AI Research
You need:BYOK — bring your own LLM key
MCP endpoint (Streamable HTTP)
https://hokmah.dev/mcp
Vendor documentation

What its tools do

7 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Can change data (1)

7 of 7 have a description · 7 of 7 declare behavior hints · 0 of 7 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Analyze impact of refactoring specific modules
  • Generate tests from architectural graph
  • Generate code with architectural memory
  • Connect GitHub repos to build graphs

Source and maintenance

Community listingRegistry 1.0.0
Maintenance checked

Protocol and capabilities

Server
hokmah 3.4.2
MCP protocol negotiated in check
2025-11-25
Tools
7 advertised
Resources
0 advertised
Resource templates
0 advertised
Prompts
0 advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": true
  },
  "logging": {},
  "prompts": {
    "listChanged": true
  },
  "resources": {
    "subscribe": false,
    "listChanged": true
  },
  "extensions": {
    "io.modelcontextprotocol/ui": {}
  },
  "experimental": {}
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Hokmah analyzes the impact of a code change on a PUBLIC GitHub repository, using a graph built from the repository's file tree and recent commit history (no language model is involved). Import a repository once with hokmah_connect_project, then call hokmah_analyze with a plain-language description of the change you plan to make; it returns a risk assessment, the files, symbols and modules likely to be affected, and related history. Use the affected files to decide what to read and test before editing. hokmah_zone_health, hokmah_compare, hokmah_similar_fixes, hokmah_risky_code and hokmah_overview say which parts work worse and what to do. Private repositories are refused; imported analyses of public repositories are shared by all users.

Tools

7 advertised

hokmah_analyze — Analyze Change Impact
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Estimates the impact of a described code change on an imported public GitHub repository. `repo_url` is https://github.com/<owner>/<repository> and `query` describes the change in plain language; `branch` is accepted for compatibility, the analysis uses the history imported from the default branch. Returns a risk assessment with the files, symbols and modules likely to be affected and related commits, computed from the repository graph without a language model.

hokmah_analyze input schema
{
  "type": "object",
  "required": [
    "repo_url",
    "query"
  ],
  "properties": {
    "query": {
      "type": "string"
    },
    "branch": {
      "type": "string",
      "default": "main"
    },
    "repo_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
hokmah_analyze output schema
{
  "type": "object",
  "additionalProperties": true
}
hokmah_analyze annotations
{
  "title": "Analyze Change Impact",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
hokmah_connect_project — Import Public GitHub Repository
Advertised by the server during the last successful anonymous check.
Open-world

Imports a public GitHub repository so it can be analyzed: indexes its source files (.py .js .ts .jsx .tsx .vue .mjs .mts .rs .go .java) and its latest commits (up to 500) from the default branch into a dependency and change-history graph. `repo_url` is https://github.com/<owner>/<repository>; `branch` is accepted for compatibility. A repository already imported is not imported again. Returns the project id and the number of commits and files ingested.

hokmah_connect_project input schema
{
  "type": "object",
  "required": [
    "repo_url"
  ],
  "properties": {
    "branch": {
      "type": "string",
      "default": "main"
    },
    "repo_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
hokmah_connect_project output schema
{
  "type": "object",
  "additionalProperties": true
}
hokmah_connect_project annotations
{
  "title": "Import Public GitHub Repository",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
hokmah_zone_health — Assess a Feature Zone
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Says how well a part of an imported repository is doing and what to do about it. `zone` is a path prefix (packages/cli/src/webhooks) or a few words ("MFA recovery codes"). Returns, from the last 12 months of history and the current code: a verdict (stable, active, growing, maintenance, fragile), fixes per feature and per 1000 lines, the recurring fix themes specific to the zone, giant files and functions, files often changed without tests, coupled areas, parallel implementations, and recommendations with the numbers behind each one. No language model is involved.

hokmah_zone_health input schema
{
  "type": "object",
  "required": [
    "repo_url",
    "zone"
  ],
  "properties": {
    "zone": {
      "type": "string"
    },
    "repo_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
hokmah_zone_health output schema
{
  "type": "object",
  "additionalProperties": true
}
hokmah_zone_health annotations
{
  "title": "Assess a Feature Zone",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
hokmah_compare — Compare Feature Zones
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Ranks 2 to 8 zones of an imported repository from the one that works worst to the one that works best, with the reasons: fixes per feature, fixes per 1000 lines and tests, over the last 12 months. Each zone is a path prefix or a few words.

hokmah_compare input schema
{
  "type": "object",
  "required": [
    "repo_url",
    "zones"
  ],
  "properties": {
    "zones": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "repo_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
hokmah_compare output schema
{
  "type": "object",
  "additionalProperties": true
}
hokmah_compare annotations
{
  "title": "Compare Feature Zones",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
hokmah_similar_fixes — Find Where a Past Bug May Still Hide
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Finds past fixes of a kind of bug ("null run data guard", "prototype pollution", "race condition on resume") in an imported repository, and the current files where the same defect may still exist: files of the same kind next to the fixed ones, files that usually change with them but were left out, and files that contain the identifiers the fix changed. Read each candidate with the fix in mind; a candidate is not a confirmed bug.

hokmah_similar_fixes input schema
{
  "type": "object",
  "required": [
    "repo_url",
    "query"
  ],
  "properties": {
    "query": {
      "type": "string"
    },
    "repo_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
hokmah_similar_fixes output schema
{
  "type": "object",
  "additionalProperties": true
}
hokmah_similar_fixes annotations
{
  "title": "Find Where a Past Bug May Still Hide",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
hokmah_risky_code — Find Code Missing a Protection
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Lists current code of an imported repository that lacks a protection the project's own fixes keep adding, learned from the diffs of its past fixes: unguarded access to structures fixes had to guard, including an entry checked to exist but read at [0] without checking it has an element, or passed to a function that dereferences it (R1); results of functions that fixes had to null-check, called the way the fixes checked them and declared nullable, used unchecked (R7); plain objects used as dictionaries keyed by request input and written through the looked-up value, obj[k].x = v (R2, prototype pollution; a one-level write is only a hardening note); template variables inserted unescaped where another file sanitizes them (R3). Optional `zone` (path prefix or words) and `kind` (R1, R2, R3, R7). kind="UI" lists the interface instead: translation keys missing from the base locale or called without the values their text needs (U1), screens that await a request on opening without handling its failure (U4), and, not validated on history, accessibility notes (U5). Each site says why it was flagged; `measured_on_history` gives, per kind, how often such sites turned out to need a fix when the detectors were run on the code of a year earlier. Candidates are not confirmed bugs.

hokmah_risky_code input schema
{
  "type": "object",
  "required": [
    "repo_url"
  ],
  "properties": {
    "kind": {
      "type": "string",
      "default": ""
    },
    "zone": {
      "type": "string",
      "default": ""
    },
    "repo_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
hokmah_risky_code output schema
{
  "type": "object",
  "additionalProperties": true
}
hokmah_risky_code annotations
{
  "title": "Find Code Missing a Protection",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
hokmah_overview — Repository Health Overview
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Overview of an imported repository: the most fragile areas (fixes per feature over 12 months), the fastest growing and the new ones, the busiest, the largest files, the most co-changed files, and how many internal imports could be resolved.

hokmah_overview input schema
{
  "type": "object",
  "required": [
    "repo_url"
  ],
  "properties": {
    "repo_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
hokmah_overview output schema
{
  "type": "object",
  "additionalProperties": true
}
hokmah_overview annotations
{
  "title": "Repository Health Overview",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

0 advertised

No prompt definitions available.

Resources

0 advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
1904 ms
95th percentile latency
1904 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 1904 ms · metadata changed · 7 tool(s), 0 resource(s), 0 resource template(s), 0 prompt(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http hokmah-mcp https://hokmah.dev/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add hokmah-mcp --url https://hokmah.dev/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable hokmah-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "hokmah-mcp": {
      "url": "https://hokmah.dev/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "hokmah-mcp": {
      "type": "streamableHttp",
      "url": "https://hokmah.dev/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start hokmah-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "hokmah-mcp": {
      "type": "http",
      "url": "https://hokmah.dev/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http hokmah-mcp https://hokmah.dev/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://hokmah.dev/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "hokmah-mcp": {
      "serverUrl": "https://hokmah.dev/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Hokmah MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.