Differences with Serena?

[jthrilly]

Hello!

Firstly, thanks for putting together this project - I think tools like this are essential for improving the capabilities of LLMs to work on larger more complex codebases. I'm excited to try this!

It seems like this project has a lot of overlaps with something I am currently using, which is Serena (https://github.com/oraios/serena).

I was wondering if anyone had any information about the core differences between them? Serena provides tools via MCP for accessing the code graph at the symbol level, via the IDE's LSP (I believe). How is this different from codanna?

Can the two work together, and if so how?

[bartolli]

Hey @jthrilly , thanks for the question! I'm actually one of Codanna's creators, so I'll try to be as fair as possible here while explaining why we built it.

Both tools help LLMs understand codebases, but they came from different needs:

Serena uses LSP (Language Server Protocol) - it's essentially giving your LLM access to the same code intelligence your IDE uses. This means it can do precise refactoring, symbol renaming, and structural edits. If you need to systematically change code across a project, Serena's LSP foundation makes that possible.

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

What we optimized for

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: We wanted the human to stay 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 (~500ms), keeping everyone in sync.

Semantic understanding: We needed to find code by concept - "where's the retry logic?" without knowing exact names. Our embedding-based search understands what code does from its documentation.

Can they work together?

In theory, yes. It depends on whether you're exploring/researching or doing systematic refactoring.

You could use Codanna for:

• Initial exploration ("what calls this?", "find all auth-related code")
• Impact analysis before changes ("what breaks if I change this?")
• Rapid context during debugging
• R&D and POC development where speed matters

Then switch to Serena when you need:

• Systematic refactoring
• Project-wide symbol renaming
• Type-safe structural changes

To be honest though, we just use Codanna for understanding and then do edits in our IDE or with the AI using regular file editing. The fast exploration usually gives enough context to make changes confidently.

Want to see what Codanna actually does? Check out these reports generated from single-sentence questions:

• File Watcher Analysis - Deep dive into our hot-reload pipeline from one question
• Adding a New Language Guide - Complete implementation guide discovered through our /find command

These were generated by our codanna-navigator agent and custom slash commands - showing how quickly you can go from question to comprehensive understanding.

My honest take

Codanna is early-stage and focused on what we needed: fast exploration and human-in-the-loop control. It's been great for our R&D workflow and intense coding sessions where you need instant context.

Serena if you need an AI that can autonomously refactor code. The LSP foundation gives it capabilities we don't have (and honestly don't plan to add - we think editing belongs in IDEs).

(Note: We do plan to add LSP support, but as a data source for better type information and cross-references, not for editing. Think of it as enriching our index with compiler-level insights while keeping our read-only, fast-lookup philosophy.)

For us, the sweet spot is using Codanna for understanding/exploration, then build agentic tools and pipes on top of it.

Happy to dig deeper into specific use cases - what kind of development are you doing?

[jthrilly]

Thanks for the detailed writeup. I'm not exactly sure I understand, though. Access to the LSP allows for symbol-based analysis of function graphs, does it not? And if the LSP has that information, and it is "fast enough" when we are manually using our IDEs, why does it become "too slow" when wanting to ask questions quickly? It routinely takes me a few seconds/minutes to formulate what exactly I need to know. Does a few additional seconds of LLM induced latency mater?

I really like the semantic aspect of your lookups though, and I agree that this isn't in the LSP's graph. But couldn't it be implemented on top of it? What "context" does codana have that isn't available to the LSP?

Part of my work involves refactoring a React 16 codebase to use React 19, and implementing new vertical systems that touch many parts of existing code, which is often not type-safe. So, these tools are extremely helpful :)

Thanks again for the answer.

[bartolli]

Thanks for pushing on these points - they really help clarify some differences!

"Why is LSP 'too slow' for rapid questions?"

It's not that LSP is inherently slow - it's about the workflow. When exploring code, you or the LLM would often ask dozens of questions in quick succession. Since Serena queries the LSP server fresh each time (they don't store relationships), those queries can add up.

"Couldn't semantic search be built on top of LSP?"

Serena's "semantic" capabilities are about code structure (through LSP) rather than similarity search. They don't appear to use vector embeddings (not to my knowledge) - their focus is on precise structural understanding.

We generate embeddings from doc comments to enable conceptual searches like "find authentication logic". This means you can search "authentication flow" and find relevant code even if not named "auth". It's complementary to what LSP provides, not a replacement.

The trade-off is that our semantic search requires good documentation comments - if there are no docs, we can't embed them.

[jthrilly]

Great information. Seems like these tools are extremely complimentary. Thanks again for taking the time to explain.