Serena

What is Serena about?

Serena is a coding‑agent toolkit that equips LLMs with symbolic code‑understanding capabilities via language‑server integration. It extracts symbols, resolves references, and performs precise edits, enabling agents to work efficiently on large, structured projects.

How to use Serena?

1. Install: Clone the repo and run the MCP server with uvx or a local installation (e.g., uv run serena start-mcp-server).
2. Configure: Optionally edit ~/.serena/serena_config.yml or project‑specific .serena/project.yml.
3. Activate a project: Either pass --project <path> when starting the server or ask the LLM to activate it ("Activate the project /path/to/my_project").
4. Integrate: Connect the server to Claude Code, Claude Desktop, VSCode extensions, terminal‑based clients, or any MCP‑compatible tool using the appropriate context (e.g., ide-assistant).
5. Run: Use the provided tools (find_symbol, insert_after_symbol, execute_shell_command, etc.) from within the LLM’s tool‑calling workflow.

Key features of Serena

• Semantic retrieval: Symbol‑level search, reference lookup, and overview generation.
• Precise editing: Rename, insert, replace, and refactor symbols using LSP‑driven operations.
• Multi‑language support: Out‑of‑the‑box LSP integration for over 30 languages (Python, TypeScript, Go, Rust, Java, etc.).
• MCP server: Model‑Context‑Protocol server usable by any client (Claude, Codex, Gemini‑CLI, VSCode, Jan, OpenHands, etc.).
• Extensible toolset: Optional tools can be enabled via contexts or modes; custom tools can be added programmatically.
• Dashboard & GUI: Web‑based dashboard for logs, usage stats, and graceful shutdown.
• Read‑only mode: Disable all mutating tools for analysis‑only scenarios.

Use cases of Serena

• Large‑scale codebase navigation: Quickly locate definitions, usages, and call graphs in monorepos.
• Automated refactoring: Rename symbols across projects without manual grep‑replace.
• Agent‑driven development: Supercharge Claude Code, Agno agents, or custom LLM agents with symbolic tooling.
• CI/CD assistance: Run shell commands, tests, and linters as part of an autonomous coding loop.
• Educational tooling: Provide step‑by‑step code exploration for learners via an IDE plugin.

FAQ

Q: Do I need an API key to run Serena? A: No. Serena is a self‑hosted MCP server; it works with any locally available LLM or remote API you connect the client to.

Q: Which language servers are required? A: Most are auto‑installed or documented in the README (e.g., gopls for Go, rust-analyzer for Rust). Missing servers must be installed manually.

Q: Can I use Serena with ChatGPT? A: Yes, via the mcpo bridge which converts MCP calls to OpenAI‑compatible tool specifications.

Q: How does Serena handle project indexing? A: Run serena project index once per project to build a cache; large projects benefit greatly from this pre‑indexing step.

Q: Is there a Windows‑compatible GUI? A: The web dashboard works on all platforms; a native GUI is available on Windows but optional.

• :rocket: Serena is a powerful coding agent toolkit capable of turning an LLM into a fully-featured agent that works directly on your codebase. Unlike most other tools, it is not tied to an LLM, framework or an interface, making it easy to use it in a variety of ways.
• :wrench: Serena provides essential semantic code retrieval and editing tools that are akin to an IDE's capabilities, extracting code entities at the symbol level and exploiting relational structure. When combined with an existing coding agent, these tools greatly enhance (token) efficiency.
• :free: Serena is free & open-source, enhancing the capabilities of LLMs you already have access to free of charge.

You can think of Serena as providing IDE-like tools to your LLM/coding agent. With it, the agent no longer needs to read entire files, perform grep-like searches or basic string replacements to find the right parts of the code and to edit code. Instead, it can use code-centric tools like find_symbol, find_referencing_symbols and insert_after_symbol.

LLM Integration

Serena provides the necessary tools for coding workflows, but an LLM is required to do the actual work, orchestrating tool use.

In general, Serena can be integrated with an LLM in several ways:

• by using the model context protocol (MCP). Serena provides an MCP server which integrates with
  • Claude Code and Claude Desktop,
  • terminal-based clients like Codex, Gemini-CLI, Qwen3-Coder, rovodev, OpenHands CLI and others,
  • IDEs like VSCode, Cursor or IntelliJ,
  • Extensions like Cline or Roo Code
  • Local clients like OpenWebUI, Jan, Agno and others
• by using mcpo to connect it to ChatGPT or other clients that don't support MCP but do support tool calling via OpenAPI.
• by incorporating Serena's tools into an agent framework of your choice, as illustrated here. Serena's tool implementation is decoupled from the framework-specific code and can thus easily be adapted to any agent framework.

Serena in Action

Demonstration 1: Efficient Operation in Claude Code

A demonstration of Serena efficiently retrieving and editing code within Claude Code, thereby saving tokens and time. Efficient operations are not only useful for saving costs, but also for generally improving the generated code's quality. This effect may be less pronounced in very small projects, but often becomes of crucial importance in larger ones.

https://github.com/user-attachments/assets/ab78ebe0-f77d-43cc-879a-cc399efefd87

Demonstration 2: Serena in Claude Desktop

A demonstration of Serena implementing a small feature for itself (a better log GUI) with Claude Desktop. Note how Serena's tools enable Claude to find and edit the right symbols.

https://github.com/user-attachments/assets/6eaa9aa1-610d-4723-a2d6-bf1e487ba753

Programming Language Support & Semantic Analysis Capabilities

Serena's semantic code analysis capabilities build on language servers using the widely implemented language server protocol (LSP). The LSP provides a set of versatile code querying and editing functionalities based on symbolic understanding of the code. Equipped with these capabilities, Serena discovers and edits code just like a seasoned developer making use of an IDE's capabilities would. Serena can efficiently find the right context and do the right thing even in very large and complex projects! So not only is it free and open-source, it frequently achieves better results than existing solutions that charge a premium.

Language servers provide support for a wide range of programming languages. With Serena's LSP library, we provide support for over 30 programming languages, including AL, Bash, C#, C/C++, Clojure, Dart, Elixir, Elm, Erlang, Fortran, Go, Haskell, Java, Javascript, Julia, Kotlin, Lua, Markdown, Nix, Perl, PHP, Python, R, Ruby, Rust, Scala, Swift, TypeScript, YAML and Zig.

[!IMPORTANT] Some languages require additional dependencies to be installed; see the Language Support page for details.

Quick Start

Prerequisites. Serena is managed by uv. If you don’t already have it, you need to install uv before proceeding.

Starting the MCP Server. The easiest way to start the Serena MCP server is by running the latest version from GitHub using uvx. Issue this command to see available options:

uvx --from git+https://github.com/oraios/serena serena start-mcp-server --help

Configuring Your Client. To connect Serena to your preferred MCP client, you typically need to configure a launch command in your client. Follow the link for specific instructions on how to set up Serena for Claude Code, Codex, Claude Desktop, MCP-enabled IDEs and other clients (such as local and web-based GUIs).

[!TIP] While getting started quickly is easy, Serena is a powerful toolkit with many configuration options. We highly recommend reading through the user guide to get the most out of Serena.

Specifically, we recommend to read about ...

• Serena's project-based workflow and
• configuring Serena.

User Guide

Please refer to the user guide for detailed instructions on how to use Serena effectively.

Community Feedback

Most users report that Serena has strong positive effects on the results of their coding agents, even when used within very capable agents like Claude Code. Serena is often described to be a game changer, providing an enormous productivity boost.

Serena excels at navigating and manipulating complex codebases, providing tools that support precise code retrieval and editing in the presence of large, strongly structured codebases. However, when dealing with tasks that involve only very few/small files, you may not benefit from including Serena on top of your existing coding agent. In particular, when writing code from scratch, Serena will not provide much value initially, as the more complex structures that Serena handles more gracefully than simplistic, file-based approaches are yet to be created.

Several videos and blog posts have talked about Serena:

• YouTube:

  • AI Labs
  • Yo Van Eyck
  • JeredBlu

• Blog posts:

  • Serena's Design Principles
  • Serena with Claude Code (in Japanese)
  • Turning Claude Code into a Development Powerhouse

Acknowledgements

Sponsors

We are very grateful to our sponsors who help us drive Serena's development. The core team (the founders of Oraios AI) put in a lot of work in order to turn Serena into a useful open source project. So far, there is no business model behind this project, and sponsors are our only source of income from it.

Sponsors help us dedicating more time to the project, managing contributions, and working on larger features (like better tooling based on more advanced LSP features, VSCode integration, debugging via the DAP, and several others). If you find this project useful to your work, or would like to accelerate the development of Serena, consider becoming a sponsor.

We are proud to announce that the Visual Studio Code team, together with Microsoft’s Open Source Programs Office and GitHub Open Source have decided to sponsor Serena with a one-time contribution!

Community Contributions

A significant part of Serena, especially support for various languages, was contributed by the open source community. We are very grateful for the many contributors who made this possible and who played an important role in making Serena what it is today.

Technologies

We built Serena on top of multiple existing open-source technologies, the most important ones being:

1. multilspy. A library which wraps language server implementations and adapts them for interaction via Python. It provided the basis for our library Solid-LSP (src/solidlsp). Solid-LSP provides pure synchronous LSP calls and extends the original library with the symbolic logic that Serena required.
2. Python MCP SDK
3. All the language servers that we use through Solid-LSP.

Without these projects, Serena would not have been possible (or would have been significantly more difficult to build).

Customizing and Extending Serena

It is straightforward to extend Serena's AI functionality with your own ideas. Simply implement a new tool by subclassing serena.agent.Tool and implement the apply method with a signature that matches the tool's requirements. Once implemented, SerenaAgent will automatically have access to the new tool.

It is also relatively straightforward to add support for a new programming language.

We look forward to seeing what the community will come up with! For details on contributing, see contributing guidelines.