> ## Documentation Index
> Fetch the complete documentation index at: https://docs.codanna.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Codanna

> Local code intelligence MCP server and CLI for AI coding agents

Codanna is a local code intelligence and semantic code search MCP server for AI coding agents. Symbol search, semantic search, call graphs, dependency tracking, document RAG. Rust, 15 languages.

## Built for Rapid Exploration

Codanna came from our need for rapid research and exploration with proper context. During R\&D, quick POCs, and pair-programming sessions, we needed instant answers about our codebase. LSP servers were too slow for that rapid-fire questioning.

**Speed for iterative exploration:** When you're in research mode or building a POC, you ask dozens of questions rapidly. Codanna's \<10ms lookups keep up with your thought process.

**Human+LLM pair programming:** The human stays in control. You can run the same queries the AI runs, pipe results through Unix tools, verify context before the AI acts. The `--watch` flag means the index updates as you code.

**Semantic understanding:** Find code by concept - "where's the retry logic?" - without knowing exact names. Embedding-based search understands what code does from its documentation.

## Why Codanna

<CardGroup cols={3}>
  <Card title="Find code by meaning" icon="magnifying-glass">
    Search by concept, not keywords.
  </Card>

  <Card title="Trace relationships" icon="diagram-project">
    Know what breaks before you change it.
  </Card>

  <Card title="Works with your AI" icon="plug">
    MCP integration with your favorite AI stack.
  </Card>
</CardGroup>

## See it work

```bash theme={null}
codanna mcp semantic_search_with_context query:"Recursively extract function calls from Go"
```

```text theme={null}
2. extract_calls_recursive - Method at src/parsing/go/parser.rs:1524-1573 [symbol_id:4146]
   Similarity Score: 0.824
   Documentation:
     Recursively extract function calls from Go AST nodes

     Traverses the syntax tree to find all function calls including:
     - Direct function calls: `functionName()`
     - Method calls: `receiver.method()`
     ...
   Signature: fn extract_calls_recursive<'a>(
        &self,
        node: &tree_sitter::Node,
        code: &'a str,
        current_function: Option<&'a str>,
        calls: &mut Vec<(&'a str, &'a str, Range)>,
    )

   extract_calls_recursive calls 2 function(s):
     -> Method extract_function_name at src/parsing/go/parser.rs:1995 [symbol_id:4156] (called at src/parsing/go/parser.rs:1553)
     -> Method extract_calls_recursive at src/parsing/go/parser.rs:1524 [symbol_id:4146] (called at src/parsing/go/parser.rs:1571)

   2 function(s) call extract_calls_recursive:
     <- Method extract_calls_recursive at src/parsing/go/parser.rs:1571 [symbol_id:4146]
     <- Method find_calls at src/parsing/go/parser.rs:2125 [symbol_id:4161]

   Changing extract_calls_recursive would impact 1 symbol(s) (max depth: 2)
```

One MCP call returns the matching symbol, its signature and docstring, the call graph in both directions with exact call sites, and the impact radius — no follow-up grep, file reads, or recursive tool calls. Every listed edge is resolution-verified: codanna reports the two calls it can prove, not every name in scope.

## Capabilities

| Capability | Surface |
| :- | :- |
| Symbol search | `find_symbol`, `search_symbols` |
| Semantic search | `semantic_search_docs`, `semantic_search_with_context` |
| Call graph | `get_calls`, `find_callers` |
| Impact analysis | `analyze_impact` |
| Document RAG | `search_documents` over markdown and text collections |
| Watch mode | `--watch` for live reindex |
| JSON envelope | every command supports `--json` (schema v1.0.0) |
| 15 languages | Rust, Python, TypeScript, JavaScript, Java, Kotlin, Go, PHP, C, C++, C#, Clojure, Lua, Swift, GDScript |
| Project-aware resolution | reads `go.mod`, `pyproject.toml`, `tsconfig.json`, `composer.json`, `pom.xml`, `build.gradle.kts`, `.csproj`, `Package.swift` |
| Remote embeddings | OpenAI-compatible HTTP via `CODANNA_EMBED_URL` |

## Works with

Codanna runs over MCP (stdio or HTTP) and composes inside Agent Skills (open standard, agentskills.io). Documented client configurations:

* **Claude Code** — `.mcp.json` (stdio or HTTP)
* **Claude Desktop** — `claude_desktop_config.json`
* **Cursor** — `.cursor/mcp.json`
* **Codex CLI** — `~/.codex/config.toml`
* **OpenCode** — `opencode.json`
* **Goose** — `~/.config/goose/config.yaml`
* **Gemini CLI** — `gemini mcp add codanna ...`

See [MCP Persistent](/reference/mcp-persistent) for full configuration snippets.

## Get Started

```bash theme={null}
curl -fsSL --proto '=https' --tlsv1.2 https://install.codanna.sh | sh
```

<Note>
  More install options (Homebrew, Cargo, Nix) in the [installation guide](/installation). See [releases](https://github.com/bartolli/codanna/releases) for the latest version.
</Note>

<CardGroup cols={2}>
  <Card title="Installation" icon="download" href="/installation">
    Install and index your first project.
  </Card>

  <Card title="Semantic Search" icon="magnifying-glass" href="/features/semantic-search">
    Search code by concept.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.