NSAF MCP Server

An MCP server for the Neuro-Symbolic Autonomy Framework (NSAF), enabling AI assistants to interact with the framework.

Neuro-Symbolic Autonomy Framework (NSAF) v1.0

The Complete, Unified Implementation of Advanced AI Autonomy

Author: Bolorerdene Bundgaa
Contact: [email protected]
Website: https://bolor.me

A comprehensive Python framework that combines quantum computing, symbolic reasoning, neural networks, and foundation models into a unified autonomous AI system.

🚀 What's New in v1.0

This is the unified, production-ready version that combines:

✅ Complete 5-Module Architecture: All advanced NSAF components
✅ Foundation Model Integration: OpenAI, Anthropic, Google APIs
✅ MCP Protocol Support: AI assistant integration built-in
✅ Web API Framework: Production deployment ready
✅ Enterprise Features: Authentication, databases, monitoring

🏗️ Architecture Overview

Core Modules

Quantum-Symbolic Task Clustering - Decompose complex problems using quantum-enhanced algorithms
Self-Constructing Meta-Agents (SCMA) - Evolve specialized AI agents automatically
Hyper-Symbolic Memory - RDF-based knowledge graphs with semantic reasoning
Recursive Intent Projection (RIP) - Multi-step planning and optimization
Human-AI Synergy - Cognitive state synchronization and collaboration

Integration Layers

Foundation Models - GPT-4, Claude, Gemini integration for embeddings and reasoning
MCP Interface - Model Context Protocol for AI assistant integration
Web APIs - FastAPI-based services with authentication
Distributed Computing - Ray-based scaling and quantum backends

🛠️ Installation

Prerequisites

Python 3.8+
8GB+ RAM recommended
GPU optional (for large models)

Quick Install

# Clone the repository
git clone https://github.com/ariunbolor/nsaf-mcp-server.git
cd nsaf-mcp-server

# Install all dependencies
pip install -r requirements.txt

# Run the unified example
python unified_example.py

Dependencies Included

Quantum Computing: Qiskit, Cirq, PennyLane
Machine Learning: PyTorch, TensorFlow, Scikit-learn
Distributed: Ray, Redis
Web Framework: FastAPI, WebSockets
Databases: SQLAlchemy, PostgreSQL, Redis
Semantic Web: RDFlib, NetworkX
Foundation Models: OpenAI, Anthropic clients

🎯 Quick Start

Basic Usage

import asyncio
from core import NeuroSymbolicAutonomyFramework

async def main():
    # Initialize the framework
    framework = NeuroSymbolicAutonomyFramework()
    
    # Define your task
    task = {
        'description': 'Build an AI system for predictive maintenance',
        'goals': [
            {'type': 'accuracy', 'target': 0.95, 'priority': 0.9},
            {'type': 'latency', 'target': 50, 'priority': 0.8}
        ],
        'constraints': [
            {'type': 'memory', 'limit': '8GB', 'importance': 0.9}
        ]
    }
    
    # Process through NSAF pipeline
    result = await framework.process_task(task)
    
    print(f"Clusters: {len(result['task_clusters'])}")
    print(f"Agents: {len(result['agents'])}")
    
    await framework.shutdown()

asyncio.run(main())

MCP Integration (AI Assistants)

from core import NSAFMCPServer

# Create MCP server for Claude/other AI assistants
server = NSAFMCPServer()

# Available tools:
# - run_nsaf_evolution
# - analyze_nsaf_memory  
# - project_nsaf_intent
# - cluster_nsaf_tasks
# - get_nsaf_status

⚙️ Configuration

Environment Variables

# Foundation Models (Optional)
export OPENAI_API_KEY="your-openai-key"
export ANTHROPIC_API_KEY="your-anthropic-key"
export GOOGLE_API_KEY="your-google-key"

# Databases (Optional)
export DATABASE_PASSWORD="your-db-password"
export REDIS_PASSWORD="your-redis-password"

# Security (Production)
export JWT_SECRET="your-jwt-secret"
export API_KEY="your-api-key"

Configuration File

All settings in config/config.yaml:

Foundation model providers and settings
Quantum backend configuration
Distributed computing setup
Database connections
Security and authentication
Feature flags and optimization

🧪 Examples

Run Complete Demo

python unified_example.py

Shows all features working together with a complex predictive maintenance task.

Individual Components

python example.py                    # Original NSAF framework
python -m core.mcp_interface        # MCP server for AI assistants

🔧 Advanced Features

Quantum Computing

IBM Qiskit integration for quantum optimization
Configurable quantum backends (simulator/real hardware)
Quantum-enhanced similarity computation

Foundation Models

Multi-provider support (OpenAI, Anthropic, Google)
Automatic fallbacks and error handling
Task-specific model selection

Distributed Processing

Ray-based distributed computing
Auto-scaling worker management
GPU/CPU resource optimization

Enterprise Ready

FastAPI web services
JWT authentication
PostgreSQL/Redis support
Monitoring and logging
Docker deployment ready

📊 Performance

Component	Performance	Scalability
Task Clustering	1000+ tasks/sec	Quantum-enhanced
Agent Evolution	100 agents/gen	Distributed training
Memory Graph	1M+ nodes	RDF triple store
Intent Planning	10 steps/sec	Recursive optimization
API Response	<100ms	Auto-scaling

🔒 Security

✅ API Authentication: JWT tokens and API keys
✅ Data Encryption: AES-256 encryption at rest
✅ Secure Connections: HTTPS/WSS only in production
✅ Access Control: Role-based permissions
✅ Audit Logging: Comprehensive activity tracking

🧰 Development

Testing

pytest tests/                       # Run all tests
pytest tests/test_integration.py    # Integration tests
pytest --cov=core tests/            # Coverage report

Code Quality

black core/                         # Format code
isort core/                         # Sort imports  
mypy core/                          # Type checking
flake8 core/                        # Linting

Documentation

sphinx-build docs/ docs/_build/     # Generate docs

🌐 Deployment

Local Development

uvicorn core.web_api:app --reload   # Web API server
ray start --head                    # Distributed computing

Production

docker build -t nsaf .              # Container build
docker-compose up -d                # Full stack deployment

Cloud Platforms

AWS: Ray on EC2, RDS PostgreSQL, ElastiCache Redis
GCP: Compute Engine, Cloud SQL, Memorystore
Azure: Virtual Machines, Database, Cache

📈 Monitoring

Metrics: Prometheus integration
Logging: Structured JSON logs
Tracing: OpenTelemetry support
Health Checks: Built-in endpoint monitoring
Alerts: Custom threshold notifications

🤝 Contributing

Fork the repository
Create feature branch: git checkout -b feature/amazing-feature
Run tests: pytest tests/
Commit changes: git commit -m 'Add amazing feature'
Push branch: git push origin feature/amazing-feature
Open Pull Request

📚 Documentation

API Reference: /docs endpoint when running server
Architecture Guide: docs/architecture.md
Deployment Guide: docs/deployment.md
Examples: examples/ directory

🐛 Troubleshooting

Common Issues

Missing Dependencies

pip install -r requirements.txt     # Install all dependencies

Quantum Backend Errors

qiskit-aer-config                   # Check quantum setup

Ray Connection Issues

ray start --head                    # Start Ray cluster
ray status                          # Check cluster status

Foundation Model API Errors

export OPENAI_API_KEY="your-key"    # Set API keys

📄 License

MIT License - see LICENSE file for details.

🙏 Acknowledgments

IBM Qiskit team for quantum computing framework
Ray team for distributed computing
OpenAI, Anthropic, Google for foundation model APIs
FastAPI team for web framework
All open source contributors

📞 Support

Issues: GitHub Issues tracker
Discussions: GitHub Discussions
Author Contact: [email protected]
Website: https://bolor.me

Built with ❤️ for the future of AI autonomy

Created by Bolorerdene Bundgaa

NSAF v1.0 - The complete neuro-symbolic autonomy solution