mcp-context-memory 0.2.0__tar.gz

mcp_context_memory-0.2.0/.github/workflows/pypi-publish.yml

@@ -0,0 +1,34 @@
+name: Release and Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build-and-publish:
+    name: Build and publish Python distributions to PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write # Mandatory for trusted publishing
+      contents: read
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+
+      - name: Build distributions
+        run: uv build
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

mcp_context_memory-0.2.0/.github/workflows/tests.yml

@@ -0,0 +1,32 @@
+name: Run Tests
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    name: Run Python Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+
+      - name: Install dependencies
+        run: uv sync --dev
+
+      - name: Run tests
+        run: uv run pytest tests/

mcp_context_memory-0.2.0/.gitignore

@@ -0,0 +1,2 @@
+.context_db
+__pycache__

mcp_context_memory-0.2.0/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-03-28
+
+### Changed
+- Converted naive Context Memory into a "Semantic Project Brain".
+- `index_project` tool introduced for AST-based code parsing using `tree-sitter`.
+- Unified `search_context` tool that searches across both semantic code chunks and manual decisions.
+- Replaced `store_context` with `remember_decision` for storing architectural reasoning.
+
+### Added
+- Support for extracting AST nodes (classes, methods, functions) for Python, Java, PHP, TypeScript, and JavaScript using `tree-sitter-languages`.
+- Structural HTML extraction using `BeautifulSoup`.
+- Added snippet for `AGENTS.md` to instruct LLMs on brain usage.
+- GitHub Action for automated releases to PyPI on tag creation.
+- Project restructuring into a proper Python package (`src/mcp_context_memory`).
+- Automated test suite using `pytest` and `pytest-mock`.
+- GitHub Action to run tests on push and pull request.
+- Explicitly set all project and dev dependencies to their latest stable versions as of March 2026.
+- Restricted Python version to 3.10-3.12 for `tree-sitter-languages` compatibility.
+
+## [0.1.0] - 2026-03-28
+
+### Added
+- Initial implementation of the Local Context Memory MCP server.
+- Basic tools: `store_context`, `query_context`, `list_all_topics`.

mcp_context_memory-0.2.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: mcp-context-memory
+Version: 0.2.0
+Summary: Semantic Project Brain MCP Server with AST Parsing
+Requires-Python: <3.13,>=3.10
+Requires-Dist: beautifulsoup4==4.14.3
+Requires-Dist: chromadb==1.5.5
+Requires-Dist: fastmcp==3.1.1
+Requires-Dist: pathspec==1.0.4
+Requires-Dist: sentence-transformers==5.3.0
+Requires-Dist: tree-sitter-languages==1.10.2
+Requires-Dist: tree-sitter==0.25.2
+Description-Content-Type: text/markdown
+
+# Semantic Project Brain MCP Server
+
+A high-end Python-based MCP (Model Context Protocol) server that provides a local, semantic memory and code-indexer. It uses `tree-sitter` for AST-based parsing of source code to understand class definitions, method signatures, and structures, rather than naive text chunking. It also acts as a "Long-Term Memory" to help AI assistants bypass context window limits by persisting architectural decisions across sessions.
+
+The server uses [ChromaDB](https://docs.trychroma.com/) for fast, local embedding storage, and stores its data in a `.context_db` folder within your current project directory.
+
+## Prerequisites
+
+You need [uv](https://github.com/astral-sh/uv) installed to run the server without managing virtual environments manually.
+
+```bash
+# Install uv if you haven't already
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+## Available Tools
+
+The server provides three MCP tools:
+1. `index_project(path: str)`: Scans a directory, parses code semantically using AST (Python, Java, PHP, TS, JS, HTML), and indexes it.
+2. `search_context(query: str)`: A unified search over AST nodes and past project decisions.
+3. `remember_decision(topic: str, context: str)`: Saves manual architectural notes or reasoning (e.g., "Why we chose framework X").
+
+## Usage with AI Assistants
+
+You can use `uvx` (part of `uv`) to run this server directly.
+
+### Claude Desktop Integration
+
+To install and use this MCP server with Claude Desktop, add the following to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "semantic-brain": {
+      "command": "uvx",
+      "args": [
+        "--from", "fastmcp",
+        "--from", "chromadb",
+        "--from", "sentence-transformers",
+        "--from", "tree-sitter",
+        "--from", "tree-sitter-languages",
+        "--from", "beautifulsoup4",
+        "--from", "pathspec",
+        "python",
+        "/path/to/this/project/src/mcp_context_memory/__init__.py"
+      ]
+    }
+  }
+}
+```
+*Note: Replace `/path/to/this/project/src/mcp_context_memory/__init__.py` with the absolute path to the file.*
+
+### Cursor Integration
+
+In Cursor, go to **Settings > Features > MCP** and add a new MCP Server:
+- **Name:** Semantic Brain
+- **Type:** `command`
+- **Command:** `uvx --from fastmcp --from chromadb --from sentence-transformers --from tree-sitter --from tree-sitter-languages --from beautifulsoup4 --from pathspec python /path/to/this/project/src/mcp_context_memory/__init__.py`
+
+## Bootstrapping an Existing Project
+
+To get the most out of the Semantic Project Brain in an existing codebase, follow these steps to seed it with relevant context:
+
+1.  **Initial Semantic Indexing**:
+    Run the indexing tool to build the initial AST-based map of your code:
+    `index_project(path=".")`
+    This allows the brain to immediately understand your classes, methods, and structural HTML.
+
+2.  **Capturing Core Architecture**:
+    Use `remember_decision` to document the foundational "Why" of the project. Good candidates for initial entries include:
+    - **Tech Stack Choice**: `remember_decision(topic="Tech Stack", context="We use Symfony 7 with PHP 8.3 because...")`
+    - **Database Schema**: `remember_decision(topic="Data Model", context="The 'Orders' table is partitioned by year to handle high volume...")`
+    - **Authentication Flow**: `remember_decision(topic="Auth", context="JWT tokens are handled via LexikJWTAuthenticationBundle with a 1-hour TTL...")`
+
+3.  **Indexing Documentation**:
+    If you have existing `DOCS.md` or `ARCHITECTURE.md` files, you can copy-paste their key insights into `remember_decision` to make them semantically searchable alongside the code.
+
+4.  **Verification**:
+    Test the brain's "memory" by asking it a question through `search_context(query="How is authentication handled?")`. If it returns your stored decisions, it's ready to assist.
+
+## Instructions for AI Agents (AGENTS.md)
+
+Copy the following block and paste it into your project's `.cursorrules`, `AGENTS.md`, or `GEMINI.md` to instruct the LLM on how to use this server:
+
+```markdown
+# Semantic Project Brain Usage Guidelines
+
+You have access to the `semantic-brain` MCP server. Follow these rules rigorously:
+
+1. **Re-indexing:** 
+   - If you make significant structural changes (e.g., creating a new module, renaming classes, or refactoring), you MUST trigger `index_project(path=".")` when you finish to keep the AST index up to date.
+   - If you cannot find expected code in `search_context`, trigger an index update first.
+
+2. **Understanding the Codebase:**
+   - Use `search_context(query="ClassName")` to understand class hierarchies, locate method definitions, and retrieve precise semantic chunks of code instead of grepping the entire workspace.
+
+3. **Remembering Decisions:**
+   - Before completing a task that involved a notable architectural decision, tradeoff, or complex logic, you are OBLIGATED to call `remember_decision(topic="...", context="...")`.
+   - Store "Why" something was built a certain way, so you and other agents can retrieve it in future sessions using `search_context`.
+```

mcp_context_memory-0.2.0/README.md

@@ -0,0 +1,100 @@
+# Semantic Project Brain MCP Server
+
+A high-end Python-based MCP (Model Context Protocol) server that provides a local, semantic memory and code-indexer. It uses `tree-sitter` for AST-based parsing of source code to understand class definitions, method signatures, and structures, rather than naive text chunking. It also acts as a "Long-Term Memory" to help AI assistants bypass context window limits by persisting architectural decisions across sessions.
+
+The server uses [ChromaDB](https://docs.trychroma.com/) for fast, local embedding storage, and stores its data in a `.context_db` folder within your current project directory.
+
+## Prerequisites
+
+You need [uv](https://github.com/astral-sh/uv) installed to run the server without managing virtual environments manually.
+
+```bash
+# Install uv if you haven't already
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+## Available Tools
+
+The server provides three MCP tools:
+1. `index_project(path: str)`: Scans a directory, parses code semantically using AST (Python, Java, PHP, TS, JS, HTML), and indexes it.
+2. `search_context(query: str)`: A unified search over AST nodes and past project decisions.
+3. `remember_decision(topic: str, context: str)`: Saves manual architectural notes or reasoning (e.g., "Why we chose framework X").
+
+## Usage with AI Assistants
+
+You can use `uvx` (part of `uv`) to run this server directly.
+
+### Claude Desktop Integration
+
+To install and use this MCP server with Claude Desktop, add the following to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "semantic-brain": {
+      "command": "uvx",
+      "args": [
+        "--from", "fastmcp",
+        "--from", "chromadb",
+        "--from", "sentence-transformers",
+        "--from", "tree-sitter",
+        "--from", "tree-sitter-languages",
+        "--from", "beautifulsoup4",
+        "--from", "pathspec",
+        "python",
+        "/path/to/this/project/src/mcp_context_memory/__init__.py"
+      ]
+    }
+  }
+}
+```
+*Note: Replace `/path/to/this/project/src/mcp_context_memory/__init__.py` with the absolute path to the file.*
+
+### Cursor Integration
+
+In Cursor, go to **Settings > Features > MCP** and add a new MCP Server:
+- **Name:** Semantic Brain
+- **Type:** `command`
+- **Command:** `uvx --from fastmcp --from chromadb --from sentence-transformers --from tree-sitter --from tree-sitter-languages --from beautifulsoup4 --from pathspec python /path/to/this/project/src/mcp_context_memory/__init__.py`
+
+## Bootstrapping an Existing Project
+
+To get the most out of the Semantic Project Brain in an existing codebase, follow these steps to seed it with relevant context:
+
+1.  **Initial Semantic Indexing**:
+    Run the indexing tool to build the initial AST-based map of your code:
+    `index_project(path=".")`
+    This allows the brain to immediately understand your classes, methods, and structural HTML.
+
+2.  **Capturing Core Architecture**:
+    Use `remember_decision` to document the foundational "Why" of the project. Good candidates for initial entries include:
+    - **Tech Stack Choice**: `remember_decision(topic="Tech Stack", context="We use Symfony 7 with PHP 8.3 because...")`
+    - **Database Schema**: `remember_decision(topic="Data Model", context="The 'Orders' table is partitioned by year to handle high volume...")`
+    - **Authentication Flow**: `remember_decision(topic="Auth", context="JWT tokens are handled via LexikJWTAuthenticationBundle with a 1-hour TTL...")`
+
+3.  **Indexing Documentation**:
+    If you have existing `DOCS.md` or `ARCHITECTURE.md` files, you can copy-paste their key insights into `remember_decision` to make them semantically searchable alongside the code.
+
+4.  **Verification**:
+    Test the brain's "memory" by asking it a question through `search_context(query="How is authentication handled?")`. If it returns your stored decisions, it's ready to assist.
+
+## Instructions for AI Agents (AGENTS.md)
+
+Copy the following block and paste it into your project's `.cursorrules`, `AGENTS.md`, or `GEMINI.md` to instruct the LLM on how to use this server:
+
+```markdown
+# Semantic Project Brain Usage Guidelines
+
+You have access to the `semantic-brain` MCP server. Follow these rules rigorously:
+
+1. **Re-indexing:** 
+   - If you make significant structural changes (e.g., creating a new module, renaming classes, or refactoring), you MUST trigger `index_project(path=".")` when you finish to keep the AST index up to date.
+   - If you cannot find expected code in `search_context`, trigger an index update first.
+
+2. **Understanding the Codebase:**
+   - Use `search_context(query="ClassName")` to understand class hierarchies, locate method definitions, and retrieve precise semantic chunks of code instead of grepping the entire workspace.
+
+3. **Remembering Decisions:**
+   - Before completing a task that involved a notable architectural decision, tradeoff, or complex logic, you are OBLIGATED to call `remember_decision(topic="...", context="...")`.
+   - Store "Why" something was built a certain way, so you and other agents can retrieve it in future sessions using `search_context`.
+```

mcp_context_memory-0.2.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "mcp-context-memory"
+version = "0.2.0"
+description = "Semantic Project Brain MCP Server with AST Parsing"
+readme = "README.md"
+requires-python = ">=3.10, <3.13"
+dependencies = [
+    "chromadb==1.5.5",
+    "fastmcp==3.1.1",
+    "sentence-transformers==5.3.0",
+    "tree-sitter==0.25.2",
+    "tree-sitter-languages==1.10.2",
+    "beautifulsoup4==4.14.3",
+    "pathspec==1.0.4",
+]
+
+[project.scripts]
+mcp-context-memory = "mcp_context_memory:mcp.run"
+
+[dependency-groups]
+dev = [
+    "pytest==9.0.2",
+    "pytest-mock==3.15.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

mcp_context_memory-0.2.0/src/mcp_context_memory/__init__.py

@@ -0,0 +1,263 @@
+import os
+import uuid
+from typing import List, Dict, Any
+from fastmcp import FastMCP
+import chromadb
+import pathspec
+from bs4 import BeautifulSoup
+from tree_sitter_languages import get_parser
+
+# Initialize the MCP server
+mcp = FastMCP("Semantic Project Brain")
+
+# Ensure the database directory exists relative to the current working directory
+DB_PATH = os.path.join(os.getcwd(), ".context_db")
+os.makedirs(DB_PATH, exist_ok=True)
+
+# Initialize ChromaDB client
+client = chromadb.PersistentClient(path=DB_PATH)
+
+# Collections
+code_collection = client.get_or_create_collection(name="code_semantics")
+decisions_collection = client.get_or_create_collection(name="project_decisions")
+
+# Supported extensions mapping to tree-sitter languages
+# tree-sitter-languages bundles these grammars (Java, Python, PHP, JS, TS, HTML, CSS)
+EXT_TO_LANG = {
+    '.py': 'python',
+    '.java': 'java',
+    '.php': 'php',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'tsx', # Uses specialized TSX grammar
+    '.css': 'css',
+    '.html': 'html',
+    '.htm': 'html'
+}
+
+# Default directories to exclude from indexing
+DEFAULT_EXCLUDES = {'node_modules', 'venv', '.venv', '.git', '__pycache__', '.context_db', 'build', 'dist', '.idea', '.vscode'}
+
+# Target AST Node Types for semantic extraction
+TARGET_TYPES = {
+    'python': {'class_definition', 'function_definition'},
+    'java': {'class_declaration', 'method_declaration'},
+    'javascript': {'class_declaration', 'method_definition', 'function_declaration'},
+    'typescript': {'class_declaration', 'method_definition', 'function_declaration'},
+    'tsx': {'class_declaration', 'method_definition', 'function_declaration'},
+    'php': {'class_declaration', 'method_declaration', 'function_declaration'},
+    'css': {'rule_set', 'media_statement'},
+    'html': {'element'} # For tree-sitter HTML, but we use BeautifulSoup as a 'specialized parser' as requested
+}
+
+def _get_gitignore_spec(path: str) -> pathspec.PathSpec:
+    """Reads .gitignore and returns a PathSpec for matching."""
+    gitignore_path = os.path.join(path, '.gitignore')
+    if os.path.exists(gitignore_path):
+        with open(gitignore_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        return pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, lines)
+    return pathspec.PathSpec.from_lines(pathspec.patterns.GitWildMatchPattern, [])
+
+def extract_ast_nodes(source_code: bytes, lang: str) -> List[Dict[str, Any]]:
+    """Extract semantic AST nodes using tree-sitter."""
+    try:
+        parser = get_parser(lang)
+        tree = parser.parse(source_code)
+        
+        extracted = []
+        target_types = TARGET_TYPES.get(lang, set())
+        
+        def traverse(node):
+            if node.type in target_types:
+                extracted.append({
+                    'node_type': node.type,
+                    'text': source_code[node.start_byte:node.end_byte].decode('utf-8', errors='ignore'),
+                    'start_line': node.start_point[0] + 1,
+                    'end_line': node.end_point[0] + 1
+                })
+            for child in node.children:
+                traverse(child)
+                
+        traverse(tree.root_node)
+        return extracted
+    except Exception as e:
+        print(f"Failed to parse {lang}: {e}")
+        return []
+
+def extract_html_semantics(content: str) -> List[Dict[str, Any]]:
+    """
+    Extract semantic structures from HTML using BeautifulSoup.
+    Fulfills the 'specialized parser' requirement for HTML structure.
+    """
+    soup = BeautifulSoup(content, 'html.parser')
+    extracted = []
+    # Index major structural elements
+    for tag in soup.find_all(['h1', 'h2', 'h3', 'section', 'article', 'div', 'form', 'nav', 'header', 'footer']):
+        text = tag.get_text(separator=' ', strip=True)
+        if len(text) > 30: # Only index chunks with substantial text content
+            extracted.append({
+                'node_type': f"html_{tag.name}",
+                'text': text[:1500], # Cap chunk size for vectorization efficiency
+                'start_line': 0,      # BS4 doesn't easily provide line numbers
+                'end_line': 0
+            })
+    return extracted
+
+@mcp.tool()
+def index_project(path: str) -> str:
+    """
+    Scans the directory, respects .gitignore, and performs AST-based decomposition
+    to index class definitions, methods, and structural HTML/CSS into 'code_semantics'.
+    
+    Args:
+        path: The absolute or relative path of the directory to index.
+    """
+    if not os.path.exists(path) or not os.path.isdir(path):
+        return f"Error: Path '{path}' is not a valid directory."
+        
+    spec = _get_gitignore_spec(path)
+    files_indexed = 0
+    chunks_indexed = 0
+    
+    for root, dirs, files in os.walk(path):
+        # Prevent traversal into excluded directories
+        dirs[:] = [d for d in dirs if d not in DEFAULT_EXCLUDES and not d.startswith('.')]
+        
+        for file in files:
+            ext = os.path.splitext(file)[1].lower()
+            if ext not in EXT_TO_LANG:
+                continue
+                
+            file_path = os.path.join(root, file)
+            rel_path = os.path.relpath(file_path, path)
+            
+            # Skip files ignored by git
+            if spec.match_file(rel_path) or any(p in rel_path.split(os.sep) for p in DEFAULT_EXCLUDES):
+                continue
+                
+            try:
+                with open(file_path, 'rb') as f:
+                    raw_content = f.read()
+            except Exception:
+                continue
+            
+            chunks = []
+            if ext in {'.html', '.htm'}:
+                # Use BeautifulSoup for HTML as requested
+                content = raw_content.decode('utf-8', errors='ignore')
+                chunks = extract_html_semantics(content)
+            else:
+                # Use Tree-sitter for all other languages (Python, Java, PHP, JS, TS, CSS)
+                lang = EXT_TO_LANG[ext]
+                chunks = extract_ast_nodes(raw_content, lang)
+                
+            if not chunks:
+                continue
+                
+            docs = []
+            metadatas = []
+            ids = []
+            
+            for i, chunk in enumerate(chunks):
+                doc_id = f"{rel_path}_{i}_{uuid.uuid4().hex[:8]}"
+                docs.append(chunk['text'])
+                metadatas.append({
+                    "file_path": rel_path,
+                    "node_type": chunk['node_type'],
+                    "start_line": chunk['start_line'],
+                    "end_line": chunk['end_line']
+                })
+                ids.append(doc_id)
+                
+            if docs:
+                code_collection.add(documents=docs, metadatas=metadatas, ids=ids)
+                files_indexed += 1
+                chunks_indexed += len(chunks)
+                
+    return f"Successfully semantically indexed {files_indexed} files into {chunks_indexed} semantic units from '{path}'."
+
+@mcp.tool()
+def remember_decision(topic: str, context: str) -> str:
+    """
+    Allows the LLM to save manual architectural notes or 'Why' something was built a certain way.
+    
+    Args:
+        topic: A short topic or category name for this decision.
+        context: The detailed reasoning, architectural decision, or context.
+    """
+    try:
+        doc_id = str(uuid.uuid4())
+        decisions_collection.add(
+            documents=[context],
+            metadatas=[{"topic": topic}],
+            ids=[doc_id]
+        )
+        return f"Decision successfully stored under topic '{topic}' with ID: {doc_id}"
+    except Exception as e:
+        return f"Error storing decision: {str(e)}"
+
+@mcp.tool()
+def search_context(query: str) -> str:
+    """
+    A unified search that looks through both code structures (AST nodes) and past project decisions.
+    
+    Args:
+        query: The search query to find relevant context.
+    """
+    try:
+        combined_results = []
+        
+        # Query code_semantics collection
+        try:
+            code_results = code_collection.query(
+                query_texts=[query], n_results=4, include=["documents", "metadatas", "distances"]
+            )
+            if code_results and code_results["documents"] and code_results["documents"][0]:
+                for doc, meta, dist in zip(code_results["documents"][0], code_results["metadatas"][0], code_results["distances"][0]):
+                    combined_results.append({"source": "Code Semantics", "content": doc, "meta": meta, "distance": dist})
+        except Exception:
+            pass 
+            
+        # Query project_decisions collection
+        try:
+            decision_results = decisions_collection.query(
+                query_texts=[query], n_results=2, include=["documents", "metadatas", "distances"]
+            )
+            if decision_results and decision_results["documents"] and decision_results["documents"][0]:
+                for doc, meta, dist in zip(decision_results["documents"][0], decision_results["metadatas"][0], decision_results["distances"][0]):
+                    combined_results.append({"source": "Project Decision", "content": doc, "meta": meta, "distance": dist})
+        except Exception:
+            pass
+            
+        if not combined_results:
+            return "No relevant context found in Code Semantics or Project Decisions."
+            
+        # Sort by distance (lower distance is more relevant in ChromaDB's default L2)
+        combined_results.sort(key=lambda x: x["distance"])
+        
+        response_parts = []
+        for idx, res in enumerate(combined_results):
+            source = res["source"]
+            meta = res["meta"] or {}
+            
+            if source == "Project Decision":
+                topic = meta.get("topic", "Uncategorized")
+                header = f"--- Result {idx + 1} ({source} | Topic: {topic}) ---"
+            else:
+                file_path = meta.get("file_path", "Unknown")
+                node_type = meta.get("node_type", "Unknown")
+                start_line = meta.get("start_line", 0)
+                end_line = meta.get("end_line", 0)
+                lines = f"Lines {start_line}-{end_line}" if start_line > 0 else "Structural"
+                header = f"--- Result {idx + 1} ({source} | File: {file_path} | Type: {node_type} | {lines}) ---"
+                
+            response_parts.append(f"{header}\n{res['content']}\n")
+            
+        return "\n".join(response_parts)
+    except Exception as e:
+        return f"Error querying context: {str(e)}"
+
+if __name__ == "__main__":
+    mcp.run()

mcp_context_memory-0.2.0/tests/test_server.py

@@ -0,0 +1,54 @@
+import pytest
+from unittest.mock import MagicMock, patch
+import mcp_context_memory
+
+@pytest.fixture
+def mock_collections():
+    with patch('mcp_context_memory.decisions_collection') as mock_decisions, \
+         patch('mcp_context_memory.code_collection') as mock_code:
+        yield mock_code, mock_decisions
+
+def test_remember_decision(mock_collections):
+    mock_code, mock_decisions = mock_collections
+    topic = "Tech Stack"
+    context = "We use Symfony 7"
+    
+    result = mcp_context_memory.remember_decision(topic, context)
+    
+    assert "Decision successfully stored" in result
+    assert topic in result
+    mock_decisions.add.assert_called_once()
+    args, kwargs = mock_decisions.add.call_args
+    assert kwargs['documents'] == [context]
+    assert kwargs['metadatas'] == [{"topic": topic}]
+
+def test_search_context_no_results(mock_collections):
+    mock_code, mock_decisions = mock_collections
+    mock_code.query.return_value = {"documents": [[]], "metadatas": [[]], "distances": [[]]}
+    mock_decisions.query.return_value = {"documents": [[]], "metadatas": [[]], "distances": [[]]}
+    
+    result = mcp_context_memory.search_context("nothing")
+    
+    assert "No relevant context found" in result
+
+def test_search_context_with_results(mock_collections):
+    mock_code, mock_decisions = mock_collections
+    
+    # Mock results
+    mock_code.query.return_value = {
+        "documents": [["class MyClass: pass"]],
+        "metadatas": [[{"file_path": "test.py", "node_type": "class_definition", "start_line": 1, "end_line": 2}]],
+        "distances": [[0.1]]
+    }
+    mock_decisions.query.return_value = {
+        "documents": [["Use Symfony because it is robust"]],
+        "metadatas": [[{"topic": "Tech Stack"}]],
+        "distances": [[0.2]]
+    }
+    
+    result = mcp_context_memory.search_context("MyClass")
+    
+    assert "Code Semantics" in result
+    assert "Project Decision" in result
+    assert "MyClass" in result
+    assert "Symfony" in result