Clojure
STDIOREPL-driven Clojure development environment connecting AI models to nREPL with syntax-aware editing tools
REPL-driven Clojure development environment connecting AI models to nREPL with syntax-aware editing tools
⚠️ Alpha Software - Work in Progress
Clojure MCP connects AI models to your Clojure development environment, enabling a remarkable REPL-driven development experience powered by large language models (LLMs).
Clojure MCP transforms LLMs into:
With Clojure MCP alone you can turn an LLM into a powerful Clojure REPL and coding assistant.
LLMs excel in the Clojure REPL: Current LLMs are unarguably fantastic Clojure REPL assistants that perform evaluations quickly and much more effectively than you can imagine. Ask anyone who has experienced this and they will tell you that the LLMs are performing much better in the Clojure REPL than they would have imagined. Additionally, we must remember that the form and maintainability of ephemeral code DOES NOT MATTER.
Buttery Smooth Clojure Editing: With current editing tools, LLMs still struggle with the parenthesis. Clojure MCP has a different take on editing that increases edit acceptance rates significantly. Clojure MCP lints code coming in, fixes parenthesis if possible, uses clj-rewrite to apply syntax aware patches, and then lints and formats the final result. This is a powerful editing pipeline that vastly outperforms when it comes to editing Clojure Code.
Together these two features along with a set of other Clojure aware tools create a new and unique LLM development experience that you probably should try at least once to understand how transformational it is.
There is a story that Clojure developers may have come to believe. The story that Modern LLMs are trained on vast amounts of code from mainstream programming languages and as a result LLMs struggle to perform well when working with niche languages like Clojure. I'm here to tell you that this is just not true.
LLMs can definitely read and write Clojure. However, our the secret weapon is the REPL and how it provides a fast focused feedback loop for LLMs to verify and refine code.
IMHO Clojure is an excellent language for LLM assisted development. All it needed was bit of a bridge... and this is what I've tried to create with ClojureMCP.
This project implements an MCP server that connects AI models to a Clojure nREPL, and specialized Clojure editing tools enabling a unique Clojure development experience.
Clojure MCP provides a superset of the tools that Claude Code uses, so you can use it to work on Clojure without any other tools.
I highly recommend using ClojureMCP with Claude Desktop to start. Claude Desktop let's you see the complete reasoning and tool execution chain which is very helpful for understanding how the LLM interacts with the tools. Seeing the explicit reasoning and actions is invaluable for learning how to work with LLMs as coding assistants.
For Clojurists an LLM assisted REPL is the killer application.
With a REPL LLMs can:
Additionally, in some LLM clients (including Claude Desktop), you can control which tools are available to the model at any given moment so you can easily remove the ability to edit files and restrict the model to the REPL tool and force the use of the REPL.
These tools are designed to work with the latest LLM models. For the best experience with sexp editing and Clojure-specific tooling, we recommend:
I highly recommend Claude 4.1 if you want to see long autonomous agentic action chains.
ClojureMCP's structural editing tools require high model performance, so using one of these recommended models will significantly improve your experience.
I personally use Claude 4.1 Opus/Sonnet for almost everything, and I'm subscribed to Anthropic's $100US/month 5x Max plan. The value I get out of it is far more than what I'm paying.
ClojureMCP can be used with almost any LLM client like Claude Desktop, Claude Code and many many more.
I use ClojureMCP with Claude Desktop because I can read the tool outputs more clearly, which helps me understand how well the tools are performing and if they are working well together to an LLM to behave as an effective Clojure coding assistant.
I also use ClojureMCP with Claude Code and works great but I make sure to turn off many of the Claude Code tools that duplicate the functionality of the ClojureMCP tools.
While you can use these tools alongside Claude Code and other code assistants with their own tooling, I recommend trying the Clojure MCP tools independently first to experience their full capabilities. Once you're comfortable with the Clojure MCP toolset, you can make informed decisions about whether to use it exclusively or integrate it with other code assistants and development tools based on your specific workflow needs.
grep and glob_files performanceSetting up ClojureMCP can be challenging as it is currently in alpha and not optimized for quick installation. This guide will walk you through the process step by step.
7888 in your projectclojure-mcp to your ~/.clojure/deps.ednclojure-mcp as an MCP server in Claude Desktop or other MCP clients.gitignore.Note: This setup verifies that all components work together. You can customize specific configuration details (like port numbers) after confirming the basic setup works.
In the Clojure project where you want AI assistance, you'll need to ensure you can start an nREPL server on port 7888 (you can use any port).
Add an :nrepl alias to your project's deps.edn:
{ ;; ... your project dependencies ... :aliases { ;; nREPL server for AI to connect to ;; Include all paths you want available for development :nrepl {:extra-paths ["test"] :extra-deps {nrepl/nrepl {:mvn/version "1.3.1"}} ;; this allows nrepl to interrupt runaway repl evals :jvm-opts ["-Djdk.attach.allowAttachSelf"] :main-opts ["-m" "nrepl.cmdline" "--port" "7888"]}}}
Verify the configuration:
$ clojure -M:nrepl
You should see the nREPL server start on port 7888.
Start an nREPL server with:
$ lein repl :headless :port 7888
Add clojure-mcp as an alias in your ~/.clojure/deps.edn:
{:aliases {:mcp {:deps {org.slf4j/slf4j-nop {:mvn/version "2.0.16"} ;; Required for stdio server com.bhauman/clojure-mcp {:git/url "https://github.com/bhauman/clojure-mcp.git" :git/tag "v0.1.11-alpha" :git/sha "7739dba"}} :exec-fn clojure-mcp.main/start-mcp-server :exec-args {:port 7888}}}}
Finding the Latest Version: Visit https://github.com/bhauman/clojure-mcp/commits/main for the latest commit SHA, or clone the repo and run
git log --oneline -1.
⚠️ Important: You must have an nREPL server running on port 7888 before starting clojure-mcp.
First, start your nREPL server in your project directory:
$ clojure -M:nrepl # or for Leiningen: $ lein repl :headless :port 7888
Then, in a new terminal, start clojure-mcp:
$ clojure -X:mcp :port 7888
You should see JSON-RPC output like this:
{"jsonrpc":"2.0","method":"notifications/tools/list_changed"} {"jsonrpc":"2.0","method":"notifications/tools/list_changed"} {"jsonrpc":"2.0","method":"notifications/resources/list_changed"} {"jsonrpc":"2.0","method":"notifications/prompts/list_changed"}
Connection Refused Error:
Execution error (ConnectException) at sun.nio.ch.Net/connect0 (Net.java:-2).
Connection refused
This means clojure-mcp couldn't connect to your nREPL server. Ensure:
Extraneous Output:
If you see output other than JSON-RPC messages, it's likely due to clojure-mcp being included in a larger environment. Ensure clojure-mcp runs with its own isolated dependencies.
clojure-mcp in your project's dependencies. It should run separately with its own deps. Always use :deps (not :extra-deps) in its alias.The MCP server accepts the following command-line arguments via clojure -X:mcp:
| Argument | Type | Description | Default | Example |
|---|---|---|---|---|
:port | integer | nREPL server port to connect to | 7888 | :port 7889 |
:host | string | nREPL server host | "localhost" | :host "192.168.1.10" |
This is often the most challenging part—ensuring the application's launch environment has the correct PATH and environment variables.
Pick the shell executable that will most likely pick up your environment config:
If you are using Bash find the explicit bash executable path:
$ which bash /opt/homebrew/bin/bash
If you are using Z Shell find the explicit zsh executable path:
$ which zsh /bin/zsh
Now we're going to use this explicit shell path in the command
parameter in the Claude Desktop configuration as seen below.
Create or edit ~/Library/Application\ Support/Claude/claude_desktop_config.json:
{ "mcpServers": { "clojure-mcp": { "command": "/opt/homebrew/bin/bash", "args": [ "-c", "clojure -X:mcp :port 7888" ] } } }
Start nREPL in your target project:
cd /path/to/your/project clojure -M:nrepl
Look for: nREPL server started on port 7888...
Restart Claude Desktop (required after configuration changes)
Verify Connection: In Claude Desktop, click the + button in the chat area. You should see "Add from clojure-mcp" in the menu. It's important to note that it may take a few moments for this to show up.
If there was an error please see the Troubleshooting Tips. If it connected go see the Starting a new conversation section.
If Claude Desktop can't run the clojure command:
which clojure works in a fresh terminalIf you continue to have issues, consider consulting with AI assistants (Claude, ChatGPT, Gemini) about the specific PATH configuration for your system setup.
If the above claude_desktop_config.json doesn't work, it's most
likely that the PATH environment variable is setup incorrectly to
find clojure and java.
Depending on your setup you can fix this directly by altering the PATH environment variable:
{ "mcpServers": { "clojure-mcp": { "command": "/opt/homebrew/bin/bash", "args": [ "-c", "export PATH=/opt/homebrew/bin:$PATH; exec clojure -X:mcp :port 7888" ] } } }
/opt/homebrew/bin/usr/local/bin/home/username/.nix-profile/bin or /nix/var/nix/profiles/default/bin/usr/bin:/usr/local/binThese are some examples to give you a way to debug a failed ClojureMCP startup.
Examine the environment:
{ "mcpServers": { "clojure-mcp": { "command": "/opt/homebrew/bin/bash", "args": [ "-c", "echo $PATH > /Users/bruce/claude-desktop-path.txt" ] } } }
Capture ClojureMCP output:
{ "mcpServers": { "clojure-mcp": { "command": "/opt/homebrew/bin/bash", "args": [ "-c", "clojure -X:mcp :port 7888 | tee /Users/bruce/clojure-mcp-stdout.log" ] } } }
If you need to source environment variables (like API keys see LLM API Keys) :
{ "mcpServers": { "clojure-mcp": { "command": "/bin/sh", "args": [ "-c", "source ~/.my-llm-api-keys.sh && PATH=/Users/username/.nix-profile/bin:$PATH && clojure -X:mcp :port 7888" ] } } }
See the Wiki for information on setting up other MCP clients.
Once everything is set up I'd suggest starting a new chat in Claude.
The first thing you are going to want to do is initialize context about the Clojure project in the conversation attached to the nREPL.
In Claude Desktop click the + tools and optionally add
PROJECT_SUMMARY.md - (have the LLM create this) see belowClojure Project Info - which introspects the nREPL connected projectLLM_CODE_STYLE.md - Which is your personal coding style instructions (copy the one in this repo to the root of your project)clojure_repl_system_prompt - instructions on how to code - cribbed a bunch from Clod CodeThen start the chat.
I would start by stating a problem and then chatting with the LLM to interactively design a solution. You can ask Claude to "propose" a solution to a problem.
Iterate on that a bit then have it either:
A. code and validate the idea in the REPL.
Don't underestimate LLMs abilities to use the REPL! Current LLMs are absolutely fantastic at using the Clojure REPL.
B. ask the LLM to make the changes to the source code and then have it validate the code in the REPL after file editing.
C. ask to run the tests. D. ask to commit the changes.
Make a branch and have the LLM commit often so that it doesn't ruin good work by going in a bad direction.
This project includes a workflow for maintaining an LLM-friendly PROJECT_SUMMARY.md that helps assistants quickly understand the codebase structure.
Creating the Summary: To generate or update the PROJECT_SUMMARY.md file, use the MCP prompt in the + > clojure-mcp menu create-update-project-summary. This prompt will:
Using the Summary: When starting a new conversation with an assistant:
Keeping It Updated: At the end of a productive session where new features or components were added:
create-update-project-summary prompt againThis workflow creates a virtuous cycle where each session builds on the accumulated knowledge of previous sessions, making the assistant increasingly effective as your project evolves.
The Clojure MCP server provides a pair of prompts that enable
conversation continuity across chat sessions using the scratch_pad
tool. By default, data is stored in memory only for the current session.
To persist summaries across server restarts, you must enable scratch pad
persistence using the configuration options described in the scratch pad section.
The system uses two complementary prompts:
chat-session-summarize: Creates a summary of the current conversation
chat_session_key parameter (defaults to "chat_session_summary")chat-session-resume: Restores context from a previous conversation
clojure_inspect_project for current project statechat_session_key parameter (defaults to "chat_session_summary")Ending a Session:
chat-session-summarize promptStarting a New Session:
chat-session-resume promptYou can maintain multiple parallel conversation contexts by using custom keys:
# For feature development
chat-session-summarize with key "feature-auth-system"
# For bug fixing
chat-session-summarize with key "debug-memory-leak"
# Resume specific context
chat-session-resume with key "feature-auth-system"
This enables switching between different development contexts while maintaining the full state of each conversation thread.
The chat summarization feature complements the PROJECT_SUMMARY.md by capturing conversation-specific context and decisions that haven't yet been formalized into project documentation.
ClojureMCP works seamlessly with shadow-cljs for ClojureScript development. Here's how to set it up:
Start your shadow-cljs server with an nREPL port:
# Start shadow-cljs (it will use port 9000 by default, or configure in shadow-cljs.edn) npx shadow-cljs watch app
Configure Claude Desktop or other client to connect to the the shadow-cljs nREPL port:
{
"mcpServers": {
"clojure-mcp": {
"command": "/bin/sh",
"args": [
"-c",
"PATH=/opt/homebrew/bin:$PATH && clojure -X:mcp :port 9000"
]
}
}
}
OR change the shadow port to 7888 (or whatever port you have configured) and leave your client config as is.
Switch to ClojureScript REPL in Claude Desktop:
Once Claude Desktop is connected, prompt Claude to evaluate:
(shadow/repl :app)
Replace :app with your actual build ID from shadow-cljs.edn.
All set! Now all clojure_eval calls will be routed to your ClojureScript REPL, allowing you to:
To exit the ClojureScript REPL and return to Clojure, have Claude evaluate:
:cljs/quit
:app, :main, :test, etc.) based on your shadow-cljs.edn configurationThis integration gives you the full power of ClojureMCP's REPL-driven development workflow for ClojureScript projects!
ClojureMCP even supports connecting to both REPLs at the same time!
Add clojure-mcp in dual mode as an alias in your ~/.clojure/deps.edn,
being sure to set the port (your nrepl port), shadow port, and shadow build as needed.
{:aliases {:mcp-shadow-dual {:deps {org.slf4j/slf4j-nop {:mvn/version "2.0.16"} ;; Required for stdio server com.bhauman/clojure-mcp {:git/url "https://github.com/bhauman/clojure-mcp.git" :git/tag "v0.1.11-alpha" :git/sha "7739dba"}} :exec-fn clojure-mcp.main-examples.shadow-main/start-mcp-server :exec-args {:port 7888 :shadow-port 7889 :shadow-build "app"}}}}
Be sure to update your claude_desktop_config.json to use the new alias.
Remember: You only need to provide arguments to the ClojureMCP server if you need to override the settings in your deps.edn.
Here is an example using the dual configuration:
Prompt to Claude:
Evaluate this expression in clojure:
(+ 1 2 3)
Claude's response:
The expression (+ 1 2 3) evaluates to 6. This is a simple addition operation in Clojure where the + function adds all the arguments together: 1 + 2 + 3 = 6.
Now try ClojureScript:
Evaluate the same expression in clojurescript, and output the result to the browser console.
Claude's response:
The expression (+ 1 2 3) evaluates to 6 in ClojureScript as well, and the result has been logged to the browser console. The function returns nil because js/console.log doesn't return a value, but if you check your browser's developer console, you should see 6 printed there.
Success!
This is NOT required to use the Clojure MCP server.
IMPORTANT: if you have the following API keys set in your environment, then ClojureMCP will make calls to them when you use the
dispatch_agent,architectandcode_critiquetools. These calls will incur API charges.
There are a few MCP tools provided that are agents unto themselves and they need API keys to function.
To use the agent tools, you'll need API keys from one or more of these providers:
GEMINI_API_KEY - For Google Gemini models
dispatch_agent, architect, code_critiqueOPENAI_API_KEY - For GPT models
dispatch_agent, architect, code_critiqueANTHROPIC_API_KEY - For Claude models
dispatch_agentOption 1: Export in your shell
export ANTHROPIC_API_KEY="your-anthropic-api-key-here" export OPENAI_API_KEY="your-openai-api-key-here" export GEMINI_API_KEY="your-gemini-api-key-here"
Option 2: Add to your shell profile (.bashrc, .zshrc, etc.)
# Add these lines to your shell profile export ANTHROPIC_API_KEY="your-anthropic-api-key-here" export OPENAI_API_KEY="your-openai-api-key-here" export GEMINI_API_KEY="your-gemini-api-key-here"
When setting up Claude Desktop, ensure it can access your environment variables by updating your config.
Personally I source them right in bash command:
{ "mcpServers": { "clojure-mcp": { "command": "/bin/sh", "args": [ "-c", "source ~/.api_credentials.sh && PATH=/your/bin/path:$PATH && clojure -X:mcp" ] } } }
Note: The agent tools will work with any available API key. You don't need all three - just set up the ones you have access to. The tools will automatically select from available models. For now the ANTHROPIC API is limited to the dispatch_agent.
This tool has a learning curve. You may in practice have to remind the LLM to develop in the REPL. You may also have to remind the LLM to use the
clojure_editfamily of tools which have linters build in to prevent unbalanced parens and the like.
The default tools included in main.clj are organized by category to support different workflows:
| Tool Name | Description | Example Usage |
|---|---|---|
LS | Returns a recursive tree view of files and directories | Exploring project structure |
read_file | Smart file reader with pattern-based exploration for Clojure files | Reading files with collapsed view, pattern matching |
grep | Fast content search using regular expressions | Finding files containing specific patterns |
glob_files | Pattern-based file finding | Finding files by name patterns like *.clj |
think | Log thoughts for complex reasoning and brainstorming | Planning approaches, organizing thoughts |
| Tool Name | Description | Example Usage |
|---|---|---|
clojure_eval | Evaluates Clojure code in the current namespace | Testing expressions like (+ 1 2) |
bash | Execute shell commands on the host system | Running tests, git commands, file operations |
| Tool Name | Description | Example Usage |
|---|---|---|
clojure_edit | Structure-aware editing of Clojure forms | Replacing/inserting functions, handling defmethod |
clojure_edit_replace_sexp | Modify expressions within functions | Changing specific s-expressions |
file_edit | Edit files by replacing text strings | Simple text replacements |
file_write | Write complete files with safety checks | Creating new files, overwriting with validation |
| Tool Name | Description | Example Usage |
|---|---|---|
dispatch_agent | Launch agents with read-only tools for complex searches | Multi-step file exploration and analysis |
architect | Technical planning and implementation guidance | System design, architecture decisions |
| Tool Name | Description | Example Usage |
|---|---|---|
scratch_pad | Persistent workspace for structured data storage | Task tracking, planning, inter-tool communication with optional file persistence (disabled by default) |
code_critique | Interactive code review and improvement suggestions | Iterative code quality improvement |
read_file)name_pattern to find functions by name, content_pattern to search content"area :rectangle" or vector dispatchesclojure_edit)clojure_eval)bash)dispatch_agent)scratch_pad)set_path, get_path, delete_path for precise data manipulationDefault Behavior (Memory-Only): By default, the scratch pad operates in memory only. Data persists during the session but is lost when the MCP server stops.
Enabling Persistence:
Add to .clojure-mcp/config.edn:
{:scratch-pad-load true ; false by default :scratch-pad-file "workspace.edn"} ; defaults to "scratch_pad.edn"
Persistence Details:
.clojure-mcp/ directory within your projectClojureMCP is designed to be highly customizable. During the alpha phase, creating your own custom MCP server is the primary way to configure the system for your specific needs.
You can customize:
The customization approach is both easy and empowering - you're essentially building your own personalized AI development companion.
📖 Complete Customization Documentation
For a quick start: Creating Your Own Custom MCP Server - This is where most users should begin.
Using the -X invocation requires EDN values.
:portOptional - The nREPL server port to connect to. When using :start-nrepl-cmd without :port, the port will be automatically discovered from the command output.
:port 7888
:hostOptional - The nREPL server host. Defaults to localhost if not specified.
:host "localhost" or :host "0.0.0.0"
:start-nrepl-cmdOptional - A command to automatically start an nREPL server if one is not already running. Must be specified as a vector of strings. The MCP server will start this process and manage its lifecycle.
When used without :port, the MCP server will automatically parse the port from the command's output. When used with :port, it will use that fixed port instead.
Important: This option requires launching clojure-mcp from your project directory (where your deps.edn or project.clj is located). The nREPL server will be started in the current working directory. This is particularly useful for Claude Code and other command-line LLM clients where you want automatic nREPL startup without manual process management.
Note for Claude Desktop users: Claude Desktop does not start MCP servers from your project directory, so :start-nrepl-cmd will not work unless you also provide :project-dir as a command line argument pointing to your specific project. For example: :project-dir '"/path/to/your/clojure/project"'. This limitation does not affect Claude Code or other CLI-based tools that you run from your project directory.
:start-nrepl-cmd ["lein" "repl" ":headless"] or :start-nrepl-cmd ["clojure" "-M:nrepl"]
:config-fileOptional - Specify the location of a configuration file. Must be a path to an existing file.
:config-file "/path/to/config.edn"
:project-dirOptional - Specify the working directory for your codebase. This overrides the automatic introspection of the project directory from the nREPL connection. Must be a path to an existing directory.
:project-dir "/path/to/your/clojure/project"
:nrepl-env-typeOptional - Specify the type of environment that we are connecting to over the nREPL connection. This overrides automatic detection. Valid options are:
:clj for Clojure or ClojureScript:bb for Babashka - Native, fast starting Clojure interpreter for scripting:basilisp for Basilisp - A Clojure-compatible Lisp dialect targeting Python 3.9+:scittle for Scittle - Execute ClojureScript directly from browser script tags:nrepl-env-type :bb
# Basic usage with just port clojure -X:mcp :port 7888 # With automatic nREPL server startup and port discovery # Perfect for Claude Code - run this from your project directory clojure -X:mcp :start-nrepl-cmd '["lein" "repl" ":headless"]' # For Claude Code with Clojure projects (from project directory) clojure -X:mcp :start-nrepl-cmd '["clojure" "-M:nrepl"]' # Auto-start with explicit port (uses fixed port, no parsing) clojure -X:mcp :port 7888 :start-nrepl-cmd '["clojure" "-M:nrepl"]' # For Claude Desktop: must provide project-dir since it doesn't run from your project clojure -X:mcp :start-nrepl-cmd '["lein" "repl" ":headless"]' :project-dir '"/path/to/your/clojure/project"' # With custom host and project directory clojure -X:mcp :port 7888 :host '"0.0.0.0"' :project-dir '"/path/to/project"' # Using a custom config file clojure -X:mcp :port 7888 :config-file '"/path/to/custom-config.edn"' # Specifying Babashka environment clojure -X:mcp :port 7888 :nrepl-env-type :bb
Note: When using -X invocation, string values need to be properly quoted for the shell, hence '"value"' syntax for strings.
The Clojure MCP server supports minimal project-specific configuration
through a .clojure-mcp/config.edn file in your project's root
directory. This configuration provides security controls and
customization options for the MCP server.
Create a .clojure-mcp/config.edn file in your project root:
your-project/
├── .clojure-mcp/
│ └── config.edn
├── src/
├── deps.edn
└── ...
Configuration is extensively documented here.
{:allowed-directories ["." "src" "test" "resources" "dev" "/absolute/path/to/shared/code" "../sibling-project"] :emacs-notify false :write-file-guard :full-read :cljfmt true :bash-over-nrepl true :scratch-pad-load false ; Default: false :scratch-pad-file "scratch_pad.edn"}
Path Resolution:
"src", "../other-project") are resolved relative to your project root"/home/user/shared") are used as-isSecurity:
Default Behavior:
{:allowed-directories ["." "src" "test" "dev" "resources" "docs"] :write-file-guard :full-read :cljfmt true :bash-over-nrepl true :scratch-pad-load false ; Memory-only scratch pad :scratch-pad-file "scratch_pad.edn"}
{:allowed-directories ["." "../shared-utils" "../common-config" "/home/user/reference-code"] :write-file-guard :partial-read :cljfmt true :bash-over-nrepl true :scratch-pad-load true ; Enable file persistence :scratch-pad-file "workspace.edn"}
{:allowed-directories ["src" "test"] :write-file-guard :full-read :cljfmt false ; Preserve original formatting :bash-over-nrepl false ; Use local execution only :scratch-pad-load false ; No persistence :scratch-pad-file "scratch_pad.edn"}
Note: Configuration is loaded when the MCP server starts. Restart the server after making configuration changes.
As mentioned above, the dispatch-agent-context configuration option allows you to add context about
your code before calling dispatch_agent. The default includes a code_index.txt file located in
the ./.clojure-mcp/ folder in your project. This can be customized, of course.
In order to generate the code index, you will need to set up an alias for this purpose, then run
clojure-mcp from the CLI.
{:aliases {:index {:deps {org.slf4j/slf4j-nop {:mvn/version "2.0.16"} ;; Required for stdio server com.bhauman/clojure-mcp {:git/url "https://github.com/bhauman/clojure-mcp.git" :git/tag "v0.1.11-alpha" :git/sha "7739dba"}} :exec-fn clojure-mcp.code-indexer/map-project :exec-args {}}}}
Then run the indexer from the CLI:
# Basic usage with default settings clojure -X:index # Customized code index generation clojure -X:index :dirs '["src" "lib"]' :include-tests true :out-file '"my-index.txt"'
Of course, you will need to specify the name of the code index file when invoking dispatch_agent.
# Run tests clojure -X:test # Run specific test clojure -X:test :dirs '["test"]' :include '"repl_tools_test"' # Run linter clojure -M:lint
The core philosophy of this project is that:
Eclipse Public License - v 2.0
Copyright (c) 2025 Bruce Hauman
This program and the accompanying materials are made available under the terms of the Eclipse Public License 2.0 which is available at http://www.eclipse.org/legal/epl-2.0