Which integrations are available for this server?

Integrates [OpenAI](/mcp/servers/integrations/openai)'s API for hybrid reasoning operations that blend neural language processing with symbolic proof search and knowledge graph querying. Provides database backend for semantic knowledge storage including RDF triples, lambda abstractions, proof trees, and vector embeddings with pgvector support. Uses [spaCy](/mcp/servers/integrations/spacy) for natural language processing in semantic decomposition and neuro-symbolic query parsing. Leverages [Supabase](/mcp/servers/integrations/supabase) PostgreSQL with pgvector for storing and querying RDF triples, proof trees, embeddings, and compositional patterns in a semantic knowledge graph.

Congo River Compositional Intelligence MCP Server

Status: 🏗️ Phase 1 in Progress (Foundation Complete!)

A production-grade MCP (Model Context Protocol) server that embodies compositional intelligence principles, providing tools for semantic decomposition, proof search, knowledge graphs, and neuro-symbolic reasoning.

🌊 The Congo River Philosophy

This project implements "Congo River Compositional Intelligence" - the idea that powerful understanding emerges from thousands of tributaries (simple reasoning operations) composing into one massive flow (deep intelligence). Key principles:

Compositional Structure: Complex reasoning built from simple, composable operations
Polyglot Architecture: Each component implemented in its optimal language
Semantic Foundations: Grounded in RDF triples, lambda calculus, and proof theory
Neuro-Symbolic Integration: Bridges neural (LLMs) and symbolic (knowledge graphs) AI

🚀 Quick Start

Prerequisites

Node.js 18+
Python 3.10+
Supabase account (or local PostgreSQL with pgvector)
Anthropic and/or OpenAI API keys

Installation

# Clone or navigate to directory cd /home/mdz-axolotl/ClaudeCode/congo-river-mcp # Install Node dependencies npm install # Install Python dependencies pip install -r requirements.txt python -m spacy download en_core_web_sm # Configure environment cp .env.example .env # Edit .env with your Supabase URL and API keys # Build TypeScript npm run build # Initialize database npm start -- --setup # Start server npm start

Configuration

Edit .env with your settings:

# Use Supabase DB_TYPE=cloud CLOUD_DB_URL=postgresql://postgres:[PASSWORD]@[PROJECT-REF].supabase.co:5432/postgres # Add your API keys ANTHROPIC_API_KEY=sk-ant-... OPENAI_API_KEY=sk-...

Add to Claude Code

Add to your .mcp.json:

{ "mcpServers": { "congo-river": { "command": "node", "args": ["dist/server.js"], "cwd": "/home/mdz-axolotl/ClaudeCode/congo-river-mcp", "type": "stdio", "env": { "TRANSPORT": "stdio", "DB_TYPE": "cloud", "CLOUD_DB_URL": "postgresql://...", "ANTHROPIC_API_KEY": "sk-ant-...", "OPENAI_API_KEY": "sk-..." } } } }

🛠️ Available Tools

Core Reasoning Tools

Decomposes concepts into RDF subject-predicate-object triples
Implements Stanley Fish's 3-word sentence principle
Stores in knowledge graph for later querying

Converts processes/code into lambda calculus
Shows compositional structure with type signatures
Applies beta reduction for simplification

Searches for proofs given goals and premises
Multiple strategies: forward/backward chaining, resolution
Returns proof trees (Curry-Howard correspondence)

Queries knowledge graph with SPARQL-like patterns
Natural language or structured queries
Returns matching triples and relationships

5. ⭐ Showcase Feature

Hybrid reasoning: LLM + knowledge graph
Parses natural language → logical form
Queries graph symbolically
Synthesizes grounded answers with proof traces

Meta Tools

Analyzes requirements and recommends optimal programming language
Shows scoring rationale and trade-offs
Demonstrates meta-level compositional intelligence

Database management: status, health, migrations, stats
Switches between local/cloud configurations

Exports knowledge graph to RDF or JSON
Backup and portability

Imports triples into knowledge graph
Bulk loading from external sources

10.

Comprehensive system health check
Database stats, service status, tool inventory

📐 Architecture

┌─────────────────────────────────────────────────┐ │ Claude Code (User) │ └────────────────┬────────────────────────────────┘ │ MCP Protocol (STDIO/SSE) ┌────────────────▼────────────────────────────────┐ │ Congo River MCP Server (TypeScript) │ │ ┌──────────────────────────────────────────┐ │ │ │ Language Selection Scoring (Meta-Layer) │ │ │ └──────────────────────────────────────────┘ │ │ ┌──────────┬──────────┬──────────────────┐ │ │ │ Core │ Advanced │ Meta Tools │ │ │ │ Tools │ Tools │ (DB, Language) │ │ │ └────┬─────┴────┬─────┴────────┬─────────┘ │ └───────┼──────────┼──────────────┼─────────────┘ │ │ │ ┌─────▼──┐ ┌───▼────┐ ┌────▼─────┐ │Python │ │TypeScr.│ │ Database │ │Services│ │Services│ │ Manager │ └────┬───┘ └───┬────┘ └────┬─────┘ └──────────┴──────────────┘ │ ┌─────────▼─────────────────────┐ │ Supabase PostgreSQL+pgvector │ │ • RDF Triples • Proofs │ │ • Embeddings • Patterns │ └───────────────────────────────┘

🗄️ Database Schema

The PostgreSQL schema includes:

triples - RDF knowledge graph storage
proofs - Proof trees and inference traces
reasoning_sessions - Tool invocation history
embeddings - Vector embeddings (pgvector)
patterns - Learned compositional patterns
lambda_abstractions - Lambda calculus representations
concept_nodes & concept_edges - Meta-level concept graph

🧠 Language Selection System

The server includes an automatic language recommendation engine that scores programming languages based on task requirements:

// Example: What language for semantic web operations? recommend_language({ task_profile: "graphQuery" }) // Result: Python (92.3/100) // Strong fit for: semantic web, graph operations // Excellent rdflib ecosystem

Supported Languages: TypeScript, Python, Prolog, Rust, Go

Scoring Dimensions:

Logic programming capabilities
Graph/RDF operations
Type system strength
Performance characteristics
ML/AI ecosystem
Semantic web support
Concurrency model
Web integration

📚 Conceptual Foundation

This system is grounded in deep theoretical connections:

J.D. Atlas - Semantic generality and presupposition
Richard Montague - Compositional semantics and type theory
Curry-Howard - Proofs as programs isomorphism
Tim Berners-Lee - RDF and semantic web
Modern LLMs - Neural learning of compositional structure

See: /home/mdz-axolotl/Documents/congo-river-compositional-intelligence.md for the complete theoretical framework.

🎯 Roadmap

✅ Phase 1 (Current)

Project structure and configuration
Database schema (PostgreSQL + pgvector)
Database manager (local/cloud support)
Language selection scoring system
Main MCP server with 10 tools
Python services implementation
TypeScript lambda service
Neuro-symbolic integration
End-to-end testing

Phase 2: Enhanced Reasoning

Tree of Thoughts orchestrator
Chain of Thought tracer

Phase 3: Meta-Cognitive Layer

Compositional analyzer (multi-lens analysis)
Loop discovery engine

Phase 4-7: Learning, Production, Knowledge Management, Advanced Neuro-Symbolic

(See full roadmap in /home/mdz-axolotl/.claude/plans/serialized-meandering-starlight.md)

🧪 Development

# Run in watch mode npm run dev # Run tests npm test # Lint npm run lint # Format npm run format # Start with SSE transport (remote access) npm run start:sse

📖 Example Usage

// In Claude Code, you can call: // Decompose a concept triple_decomposition({ concept: "Consciousness is awareness of internal and external stimuli", store_in_db: true }) // Get language recommendation recommend_language({ task_profile: "neuroSymbolic", show_all: true }) // Query knowledge graph graph_query({ query: "Find all properties of consciousness" }) // Neuro-symbolic reasoning neuro_symbolic_query({ query: "What is the relationship between consciousness and qualia?", include_proof: true }) // System health system_status({ detailed: true })

🤝 Contributing

This is a research/educational project exploring compositional intelligence. Contributions welcome!

📄 License

MIT

**🌊 The Congo River flows with unstoppable force from thousands of tributaries composing into one.**Human: can we save this session?

Congo River Compositional Intelligence