Kaimon.jl

Opening the gate between AI and Julia.

CI Docs Julia 1.12+ License: MIT

Kaimon is an MCP (Model Context Protocol) server that gives AI agents full access to Julia's runtime. Connect Claude Code, Cursor, or any MCP client to a live Julia session with a focused default surface of 49 tools for code execution, introspection, debugging, testing, and code search.

Key Features

• Live Code Execution — evaluate Julia code in persistent REPL sessions with full state, package access, and streaming output
• Deep Introspection — inspect types, methods, lowered IR, type-inferred code, and macro expansions directly from the agent
• The Gate — connect external Julia processes and register custom tools via ZMQ. Your app's domain logic becomes agent-callable with automatic schema generation
• Interactive Debugging — Infiltrator.jl integration with breakpoints, variable inspection, and expression evaluation at pause points
• Semantic Code Search — index projects into Qdrant and search with natural language queries like "function that handles HTTP routing"
• Terminal Dashboard — real-time TUI monitoring sessions, tool calls, test runs, and search results across all connected REPLs
• Security — three modes (strict/relaxed/lax), API key management, IP allowlists
• Testing & Profiling — run tests with pattern filtering and coverage, profile code, stress-test with concurrent simulated agents

Quick Start

]app add Kaimon

This installs the kaimon command to ~/.julia/bin/ (make sure it's on your PATH). Then:

kaimon

The first run opens a setup wizard (security mode, API key, port). After that, the terminal dashboard launches:

From the dashboard:

• Press i in the Config tab to write MCP config for Claude Code, Cursor, VS Code, or Gemini CLI
• Press g to add a Gate snippet to ~/.julia/config/startup.jl so every Julia session auto-connects
• Or connect manually from any REPL: ]add KaimonGate; using KaimonGate; KaimonGate.serve()

Tool Categories

Category	Tools	Description
Code Execution	ex, manage_repl	Evaluate code, restart/shutdown sessions
Introspection	investigate_environment, search_methods, type_info, list_names, workspace_symbols, document_symbols, macro_expand	Explore types, methods, and symbols
Code Analysis	code_lowered, code_typed, format_code, lint_package	IR inspection, formatting, linting
Navigation	goto_definition, navigate_to_file	Jump to definitions and source locations
VS Code	execute_vscode_command, list_vscode_commands	VS Code command execution
Debugging	debug_ctrl, debug_eval, debug_exfiltrate, debug_safehouse	Infiltrator.jl breakpoint debugging
Packages	pkg_add, pkg_rm	Add/remove packages
Testing	run_tests, stress_test	Test execution, load testing
Search	search_code, grep_code, qdrant_index_project, qdrant_sync_index, qdrant_reindex_file, qdrant_list_collections	search_code finds code by meaning (hybrid semantic + lexical); grep_code runs an exact pattern/regex over the live tree and returns each hit's enclosing symbol
Agents	agent_open, agent_send, agent_run, agent_output, agent_status, agent_list, agent_interrupt, agent_close	Spawn & drive headless claude agents
Extensions	extension_info, manage_extension	Inspect & control extension lifecycle
Info	ping, usage_instructions, usage_quiz, tool_help	Server status and documentation

Advanced/infra tools (IR inspection code_lowered/code_typed, macro_expand, profile_code, lint_package, and the raw Qdrant vector-DB admin tools) are gated off the default surface to keep tool selection focused -- enable them per project in .kaimon/tools.json.

The Gate

The gate is a separately installable, lightweight package — KaimonGate (ZMQ + stdlib only, no heavy deps) — so you can drop it into any project, or onto a remote/compute node, without the full Kaimon dependency tree:

]add KaimonGate

Connect any Julia process and expose domain-specific tools to AI agents:

using KaimonGate: GateTool, serve

function analyze_data(path::String, threshold::Float64=0.95)
    data = load(path)
    filter(x -> x.score > threshold, data)
end

# Kaimon auto-generates the MCP schema from the function signature
serve(tools=[GateTool("analyze_data", analyze_data)])

The connected REPL appears as a session in Kaimon's TUI. The agent can call analyze_data alongside all built-in tools, with full argument validation and type checking. The full Kaimon install bundles KaimonGate automatically (a deprecated Kaimon.Gate alias keeps old Gate.serve() snippets working).

Documentation

Full documentation: kahliburke.github.io/Kaimon.jl

Requirements

• Julia 1.12+
• Any MCP-compatible client (Claude Code, Cursor, VS Code with Copilot Chat or Continue, Gemini CLI). VS Code's Copilot Chat / Continue speak MCP natively — no extra extension needed; press i in the Config tab to write the client config (.vscode/mcp.json).
• Optional: Qdrant for semantic code search
• Optional: Kaimon's built-in VS Code extension — install from the Config tab with v (or run Kaimon.install_vscode_remote_control()) — to enable the in-editor command tools (execute_vscode_command, list_vscode_commands, navigate_to_file).

Contributing

Contributions are welcome. Please open an issue to discuss changes before submitting a pull request.

License

MIT

---

Kaimon (開門) — "opening the gate." The gate between AI agents and the Julia ecosystem.