Stores knowledge about code entities, relationships, patterns, and style conventions from a codebase, with support for incremental updates when code changes.
Referenced for source code management and contributions, allowing users to clone the repository and submit pull requests.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@sourcesage register the UserService class from our authentication module"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
SourceSage is an MCP (Model Context Protocol) server that efficiently memorizes key aspects of a codebase—logic, style, and standards—while allowing dynamic updates and fast retrieval. It's designed to be language-agnostic, leveraging the LLM's understanding of code across multiple languages.
Language Agnostic: Works with any programming language the LLM understands
Knowledge Graph Storage: Efficiently stores code entities, relationships, patterns, and style conventions
LLM-Driven Analysis: Relies on the LLM to analyze code and provide insights
Token-Efficient Storage: Optimizes for minimal token usage while maximizing memory capacity
Incremental Updates: Updates knowledge when code changes without redundant storage
Fast Retrieval: Enables quick and accurate retrieval of relevant information
Related MCP server: Logseq MCP Tools
SourceSage uses a novel approach where:
The LLM analyzes code files (in any language)
The LLM uses MCP tools to register entities, relationships, patterns, and style conventions
SourceSage stores this knowledge in a token-efficient graph structure
The LLM can later query this knowledge when needed
This approach leverages the LLM's inherent language understanding while focusing the MCP server on efficient memory management.
# Clone the repository
git clone https://github.com/yourusername/sourcesage.git
cd sourcesage
# Install the package
pip install -e .# Run the server
sourcesage
# Or run directly from the repository
python -m sourcesage.mcp_serverOpen Claude for Desktop
Go to Settings > Developer > Edit Config
Add the following to your claude_desktop_config.json:
If you've installed the package:
{
"mcpServers": {
"sourcesage": {
"command": "sourcesage",
"args": []
}
}
}If you're running from a local directory without installing:
{
"sourcesage": {
"command": "uv",
"args": [
"--directory",
"/path/to/sourcesage",
"run",
"main.py"
]
},
}Restart Claude for Desktop
SourceSage provides the following MCP tools:
register_entity: Register a code entity in the knowledge graph
Input:
- name: Name of the entity (e.g., class name, function name)
- entity_type: Type of entity (class, function, module, etc.)
- summary: Brief description of the entity
- signature: Entity signature (optional)
- language: Programming language (optional)
- observations: List of observations about the entity (optional)
- metadata: Additional metadata (optional)
Output: Confirmation message with entity IDregister_relationship: Register a relationship between entities
Input:
- from_entity: Name of the source entity
- to_entity: Name of the target entity
- relationship_type: Type of relationship (calls, inherits, imports, etc.)
- metadata: Additional metadata (optional)
Output: Confirmation message with relationship IDregister_pattern: Register a code pattern
Input:
- name: Name of the pattern
- description: Description of the pattern
- language: Programming language (optional)
- example: Example code demonstrating the pattern (optional)
- metadata: Additional metadata (optional)
Output: Confirmation message with pattern IDregister_style_convention: Register a coding style convention
Input:
- name: Name of the convention
- description: Description of the convention
- language: Programming language (optional)
- examples: Example code snippets demonstrating the convention (optional)
- metadata: Additional metadata (optional)
Output: Confirmation message with convention IDadd_entity_observation: Add an observation to an entity
Input:
- entity_name: Name of the entity
- observation: Observation to add
Output: Confirmation messagequery_entities: Query entities in the knowledge graph
Input:
- entity_type: Filter by entity type (optional)
- language: Filter by programming language (optional)
- name_pattern: Filter by name pattern (regex, optional)
- limit: Maximum number of results to return (optional)
Output: List of matching entitiesget_entity_details: Get detailed information about an entity
Input:
- entity_name: Name of the entity
Output: Detailed information about the entityquery_patterns: Query code patterns in the knowledge graph
Input:
- language: Filter by programming language (optional)
- pattern_name: Filter by pattern name (optional)
Output: List of matching patternsquery_style_conventions: Query coding style conventions
Input:
- language: Filter by programming language (optional)
- convention_name: Filter by convention name (optional)
Output: List of matching style conventionsget_knowledge_statistics: Get statistics about the knowledge graph
Input: None
Output: Statistics about the knowledge graphclear_knowledge: Clear all knowledge from the graph
Input: None
Output: Confirmation messageAnalyze Code: Ask Claude to analyze your code files
"Please analyze this Python file and register the key entities and relationships."Register Entities: Claude will use the register_entity tool to store code entities
"I'll register the main class in this file."Register Relationships: Claude will use the register_relationship tool to store relationships
"I'll register the inheritance relationship between these classes."Query Knowledge: Later, ask Claude about your codebase
"What classes are defined in my codebase?"
"Show me the details of the User class."
"What's the relationship between the User and Profile classes?"Get Coding Patterns: Ask Claude about coding patterns
"What design patterns are used in my codebase?"
"Show me examples of the Factory pattern in my code."Unlike traditional code analysis tools, SourceSage:
Leverages LLM Understanding: Uses the LLM's ability to understand code semantics across languages
Stores Semantic Knowledge: Focuses on meaning and relationships, not just syntax
Is Language Agnostic: Works with any programming language the LLM understands
Optimizes for Token Efficiency: Stores knowledge in a way that minimizes token usage
Evolves with LLM Capabilities: As LLMs improve, so does code understanding
Contributions are welcome! Please feel free to submit a Pull Request.
This project is licensed under the MIT License - see the LICENSE file for details.
Add an observation to an entity.
Args: entity_name: Name of the entity observation: Observation to add
Inputs: entity_name (required), observation (required).
Clear all knowledge from the graph.
Inputs: no named parameters.
Dump understanding of an entire project at once.
This tool provides a comprehensive dump of all knowledge related to a project, including all entities, relationships, patterns, and style conventions.
Args: project_path: Path to the project root directory include_observations: Whether to include detailed observations
Inputs: project_path (required), include_observations.
Get detailed information about an entity.
Args: entity_name: Name of the entity
Inputs: entity_name (required).
Get statistics about the knowledge graph.
Inputs: no named parameters.
Load understanding of an entire project at once.
This tool should be used by MCP clients to quickly get project understanding if available, instead of reading all the files individually. It loads all entities, relationships, patterns, and style conventions related to the project.
Args: project_path: Path to the project root directory
Inputs: project_path (required).
Query entities in the knowledge graph.
Args: entity_type: Filter by entity type (class, function, module, etc.) language: Filter by programming language name_pattern: Filter by name pattern (regex) limit: Maximum number of results to return
Inputs: entity_type, language, limit, name_pattern.
Query code patterns in the knowledge graph.
Args: language: Filter by programming language pattern_name: Filter by pattern name
Inputs: language, pattern_name.
Query coding style conventions in the knowledge graph.
Args: language: Filter by programming language convention_name: Filter by convention name
Inputs: convention_name, language.
Register a code entity in the knowledge graph.
Args: name: Name of the entity (e.g., class name, function name) entity_type: Type of entity (class, function, module, etc.) summary: Brief description of the entity signature: Entity signature (e.g., function signature) language: Programming language observations: List of observations about the entity metadata: Additional metadata as key-value pairs
Inputs: entity_type (required), name (required), summary (required), language, +3 more.
Register a code pattern.
Args: name: Name of the pattern description: Description of the pattern language: Programming language example: Example code demonstrating the pattern metadata: Additional metadata as key-value pairs
Inputs: description (required), name (required), example, language, +1 more.
Register a relationship between entities.
Args: from_entity: Name of the source entity to_entity: Name of the target entity relationship_type: Type of relationship (calls, inherits, imports, etc.) metadata: Additional metadata as key-value pairs
Inputs: from_entity (required), relationship_type (required), to_entity (required), metadata.
Register a coding style convention.
Args: name: Name of the convention description: Description of the convention language: Programming language examples: Example code snippets demonstrating the convention metadata: Additional metadata as key-value pairs
Inputs: description (required), name (required), examples, language, +1 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 13 tools
Most tools have distinct purposes focused on different aspects of knowledge graph management (entities, patterns, relationships, style conventions). However, there is some potential overlap between dump_project_understanding and load_project_understanding as both handle project-level data, though their descriptions clarify one is for output and the other for input.
All tools follow a consistent snake_case naming pattern with clear verb_noun structure (e.g., add_entity_observation, get_entity_details, query_entities, register_entity). The naming is predictable and uniform across all 13 tools.
With 13 tools, this is well-scoped for a knowledge graph server covering entities, patterns, relationships, and style conventions. Each tool serves a specific function in the CRUD/lifecycle operations, and none appear redundant or out of place.
The toolset provides comprehensive coverage for managing a knowledge graph, including registration, querying, and statistics. Minor gaps exist, such as no explicit update or delete operations for entities/patterns/relationships/conventions, but agents can work around this by re-registering or using clear_knowledge.
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
Shared memory for coding agents. Stop re-explaining your codebase every session.
Give your AI agent persistent, governed memory for every project. At task start it recalls the approved decisions, conventions, risks and architecture (semantic search, ranked by importance); at close it proposes what was learned as typed memories that you review and approve — governance, not a notes dump. Agents propose, humans govern: edits go back to pending and deletion is human-only by design. Connect Claude Code, Cursor, Claude Desktop or any MCP client in two minutes with just your API key — hosted (nothing to install) or locally via `uvx solucortex-mcp`. Built by SoluAI and dogfooded daily: SoluCortex is developed using its own living memory.
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
