Project Synapse MCP

🚀 Project Synapse MCP Server

Project Synapse is a revolutionary MCP (Model Context Protocol) server that converts raw text into interconnected knowledge graphs and autonomously generates insights through advanced pattern detection. It combines formal semantic analysis with Zettelkasten methodology to establish a true cognitive partnership with AI.

✨ Features

🔬 Semantic Blueprint (Montague Grammar)

• Conduct formal semantic analysis to precisely extract meaning.
• Utilize lambda calculus for compositional semantics.
• Generate logical forms from natural language.
• Resolve ambiguity through rule - based frameworks.

🕸️ Knowledge Cortex (Neo4j Graph Database)

• Store entities, relationships, and facts in an interconnected manner.
• Perform high - performance graph traversal and pattern detection.
• Support a scalable architecture for complex queries.
• Track the provenance of all knowledge elements.

🧮 Autonomous Zettelkasten Engine

• Detect patterns using graph algorithms and machine learning.
• Generate insights autonomously with confidence scoring.
• Provide auditable reasoning trails for all hypotheses.
• Continuously learn and synthesize knowledge.

🔄 MCP Integration

• Fully comply with the MCP protocol for LLM integration.
• Offer a rich toolset for knowledge manipulation.
• Provide real - time resources for knowledge statistics.
• Offer guided prompts for semantic analysis workflows.

🚀 Quick Start

Prerequisites

• Python 3.10+
• Neo4j Database
• uv package manager (recommended)

Installation

1. Clone and setup project:

cd /home/ty/Repositories/ai_workspace
git clone <repository-url> project-synapse-mcp
cd project-synapse-mcp

# Create virtual environment
uv venv --python 3.12 --seed
source .venv/bin/activate

# Install dependencies
uv add -e .

2. Setup Neo4j Database:

# Install Neo4j (Ubuntu/Debian)
sudo apt update
sudo apt install neo4j

# Start Neo4j service
sudo systemctl start neo4j
sudo systemctl enable neo4j

# Set password (default user: neo4j)
sudo neo4j-admin set-initial-password synapse_password

3. Download spaCy model:

uv run python -m spacy download en_core_web_sm

4. Configure environment:

cp .env.example .env
# Edit .env with your configuration

Claude Desktop Integration

Add the following to your Claude Desktop configuration file (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "project-synapse": {
      "command": "uv",
      "args": [
        "--directory",
        "/path-to-your/project-synapse-mcp",
        "run",
        "python",
        "-m",
        "synapse_mcp.server"
      ],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USER": "neo4j",
        "NEO4J_PASSWORD": "<your-neo4j-password>",
        "NEO4J_DATABASE": "neo4j",
        "LOG_LEVEL": "INFO"
      }
    }
  }
}

💻 Usage Examples

Basic Usage

Ingesting Text

Ingest raw text → Montague Grammar parsing → Entity extraction →
Knowledge graph storage → Automatic insight generation

Advanced Usage

Generating Insights

• Detect patterns using graph algorithms.
• Conduct community detection and centrality analysis.
• Perform semantic clustering and path analysis.
• Generate confidence - scored hypotheses.

Querying Knowledge

• Use natural language querying with insight - first responses.
• Prioritize synthesized insights over raw facts.
• Provide complete reasoning trails.
• Support complex semantic queries.

Exploring Connections

• Explore multi - hop connections.
• Identify unexpected pathways.
• Analyze relationship strength.

Analyzing Semantic Structure

• Generate logical forms.
• Extract entity - relationships.
• Analyze truth - conditional semantics.
• Perform compositional meaning analysis.

📚 Documentation

Resources

synapse://knowledge_stats

• Obtain real - time knowledge graph statistics, including entity and relationship counts, insight generation metrics, processing performance data, and system health indicators.

synapse://insights/{topic}

• Retrieve all insights related to a topic, along with evidence trails, confidence scores, pattern type classification, and chronological insight development.

Prompts

Knowledge Synthesis Prompt

A structured prompt for comprehensive topic analysis using formal semantic reasoning and Zettelkasten methodology.

Semantic Analysis Prompt

A multi - turn conversation template for deep Montague Grammar - based semantic analysis.

Insight Validation Prompt

Systematically validate AI - generated insights against evidence and logical consistency.

Architecture

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Text Input    │───▶│  Montague Parser │───▶│ Knowledge Graph │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                                                         │
┌─────────────────┐    ┌──────────────────┐             │
│   MCP Client    │◀───│  Insight Engine  │◀────────────┘
│   (Claude AI)   │    │  (Zettelkasten)  │
└─────────────────┘    └──────────────────┘

Components

1. Semantic Blueprint: A Montague Grammar parser for formal meaning analysis.
2. Knowledge Cortex: A Neo4j graph database for interconnected storage.
3. Zettelkasten Engine: An autonomous pattern detection and insight synthesis engine.
4. MCP Interface: A protocol - compliant integration with LLM applications.

Configuration

Environment Variables

Refer to .env.example for complete configuration options, including Neo4j connection settings, API keys for various AI model providers, processing batch sizes and thresholds, and insight generation confidence levels and intervals.

Performance Tuning

• Adjust SEMANTIC_BATCH_SIZE to improve processing throughput.
• Configure PATTERN_DETECTION_INTERVAL to control insight generation frequency.
• Set INSIGHT_CONFIDENCE_THRESHOLD for quality control.

🔧 Technical Details

Theoretical Foundation

Montague Grammar

• Formal compositional semantics.
• Lambda calculus for meaning representation.
• Model - theoretic truth conditions.
• Systematic syntax - semantics correspondence.

Zettelkasten Method

• Atomic knowledge units with unique identifiers.
• Explicit linking for knowledge networks.
• Emergent structure through bottom - up organization.
• Continuous expansion and connection building.

Graph Theory

• Community detection for knowledge clustering.
• Centrality analysis for importance ranking.
• Path analysis for connection discovery.
• Network topology for insight generation.

🤝 Contributing

1. Fork the repository.
2. Create a feature branch (git checkout -b feature/amazing-feature).
3. Commit your changes (git commit -m 'Add amazing feature').
4. Push to the branch (git push origin feature/amazing-feature).
5. Open a Pull Request.

Development Guidelines

• Follow PEP 8 and use type hints.
• Write comprehensive docstrings.
• Include tests for new functionality.
• Update documentation for changes.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Acknowledge the foundational work of Richard Montague on Montague Grammar.
• Recognize the inspiration from Niklas Luhmann's Zettelkasten methodology.
• Appreciate the MCP protocol by Anthropic for LLM integration.
• Thank Neo4j for its excellent graph database.

🔮 Roadmap

• [ ] Implement multi - modal processing (images, documents).
• [ ] Enable real - time collaborative knowledge building.
• [ ] Advance NLP beyond Montague Grammar.
• [ ] Integrate with external knowledge bases.
• [ ] Develop mobile and web interfaces.
• [ ] Add enterprise security features.

Project Synapse: Transforming AI from reactive information retrieval to proactive cognitive partnership.