LYRAIOS

by GalaxyLLMCI

136 stars

208 downloads

Not rated

GitHub Website

Other

About

LYRAI is a Model Context Protocol (MCP) operating system for multi-AI AGENTs designed to extend the functionality of AI applications by enabling them to interact with financial networks and blockchain public chains. The server offers a range of advanced AI assistants, including b

Details

Author: GalaxyLLMCI
GitHub stars: 136
Downloads: 208
Categories: Other

- Open Protocol Architecture with plug-and-play third-party tool integration
- Multi-Agent Collaboration Engine for distributed task orchestration
- Cross-Platform Runtime Environment for seamless AI agent migration
- Built-in tools: Calculator, Web Search, Financial Analysis, File Management
- Specialized assistant teams: Python Assistant and Research Assistant
- AI Memory System with short-term and long-term vector database storage
- Security & Access Control with authentication, authorization, and rate limiting

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name LYRAIOS

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

From the repository

Deploy LYRAIOS using Docker for containerized development or production. Access the system through its Streamlit web UI, command-line interface (CLI), or REST API (FastAPI backend). Configure environment variables for API keys, database connections, and tool integrations. Tool developers can define JSON manifests and register them via the Tool Integration Protocol.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "lyraios": {
            "lyraios": {
                "command": "python3",
                "args": [
                    "-m",
                    "venv",
                    "aienv"
                ]
            }
        }
    }
}

McpServers

{
    "lyraios": {
        "command": "python3",
        "args": [
            "-m",
            "venv",
            "aienv"
        ]
    }
}

LYRAIOS

Overview & Technical Foundation

LYRAI is a Model Context Protocol (MCP) operating system for multi-AI AGENTs designed to extend the functionality of AI applications (such as Claude Desktop and Cursor) by enabling them to interact with financial networks and blockchain public chains. The server offers a range of advanced AI assistants, including blockchain public chain operations (SOLANA, ETH, etc. - retrieving wallet addresses, listing wallet balances, transferring funds, deploying smart contracts, on-chain lending, calling contract functions, managing tokens), fintech market analysis and summary reports, and learning and training systems for the education sector.

> In the future operation of LYRAIOS, advanced VIP features will exclusively support payment using LYRAI on solana, with LYRAI's CA : A6MTWuHbXqjH3vYEfbs3mzvGThQtk5S12FjmdpVkpump

Welcome to check out the demo of our LYRA MCP-OS!

https://github.com/user-attachments/assets/479cad58-ce4b-4901-93ff-e60a98c477d4

Core Innovations & Differentiated Value

LYRAIOS aims to create the next generation AI Agent operating system with technological breakthroughs in three dimensions:

1. Open Protocol Architecture: Pioneering modular integration protocol supporting plug-and-play third-party tools/services, compatible with multi-modal interaction interfaces (API/plugins/smart hardware), with 80%+ improved extensibility compared to traditional frameworks
2. Multi-Agent Collaboration Engine: Breaking through single Agent capability boundaries through distributed task orchestration system enabling dynamic multi-agent collaboration, supporting enterprise-grade complex workflow automation and conflict resolution
3. Cross-Platform Runtime Environment: Building cross-terminal AI runtime environment, enabling smooth migration from personal intelligent assistants to enterprise digital employees, applicable for validating multi-scenario solutions in finance, healthcare, intelligent manufacturing and other fields

For detailed architecture information, see the Architecture Documentation.

System Architecture

LYRAIOS adopts a layered architecture design, from top to bottom, including the user interface layer, core OS layer, MCP integration layer, and external services layer.

LYRAIOS Architecture

MANUS Architecture

User Interface Layer

The user interface layer provides multiple interaction modes, allowing users to interact with the AI OS.

Components:

- Web UI: Based on Streamlit, providing an intuitive user interface
- Mobile UI: Mobile adaptation interface, supporting mobile device access
- CLI: Command line interface, suitable for developers and advanced users
- API Clients: Provide API interfaces, supporting third-party application integration

Core OS Layer

The core OS layer implements the basic functions of the AI operating system, including process management, memory system, I/O system, and security control.

Components:

- Process Management
- Task Scheduling: Dynamic allocation and scheduling of AI tasks
- Resource Allocation: Optimize AI resource usage
- State Management: Maintain AI process state

- Memory System
- Short-term Memory: Session context maintenance
- Long-term Storage: Persistent knowledge storage
- Knowledge Base: Structured knowledge management

- I/O System
- Multi-modal Input: Handle text, files, APIs, etc.
- Structured Output: Generate formatted output results
- Event Handling: Respond to system events

- Security & Access Control
- Authentication: User authentication
- Authorization: Permission management
- Rate Limiting: Prevent abuse

MCP Integration Layer

MCP Integration Layer is the core innovation of the system, achieving seamless integration with external services through the Model Context Protocol.

Components:

- MCP Client
- Protocol Handler: Process MCP protocol messages
- Connection Management: Manage connections to MCP servers
- Message Routing: Route messages to appropriate processors

- Tool Registry
- Tool Registration: Register external tools and services
- Capability Discovery: Discover tool capabilities
- Manifest Validation: Validate tool manifests

- Tool Executor
- Execution Environment: Provide an execution environment for tool execution
- Resource Management: Manage the resources used by tool execution
- Error Handling: Handle errors during tool execution

- Adapters
- REST API Adapter: Connect to REST API services
- Python Plugin Adapter: Integrate Python plugins
- Custom Adapter: Support other types of integration

External Services Layer

The external services layer includes various services integrated through the MCP protocol, which act as MCP servers providing capabilities.

Components:

- File System: Provide file read and write capabilities
- Database: Provide data storage and query capabilities
- Web Search: Provide internet search capabilities
- Code Editor: Provide code editing and execution capabilities
- Browser: Provide web browsing and interaction capabilities
- Custom Services: Support other custom services integration

Tool Integration Protocol

The Tool Integration Protocol is a key component of LYRAIOS's Open Protocol Architecture. It provides a standardized way to integrate third-party tools and services into the LYRAIOS ecosystem.

Key Features

- Standardized Tool Manifest: Define tools using a JSON schema that describes capabilities, parameters, and requirements
- Pluggable Adapter System: Support for different tool types (REST API, Python plugins, etc.)
- Secure Execution Environment: Tools run in a controlled environment with resource limits and permission checks
- Versioning and Dependency Management: Track tool versions and dependencies
- Monitoring and Logging: Comprehensive logging of tool execution

Getting Started with Tool Integration

1. Define Tool Manifest: Create a JSON file describing your tool's capabilities
2. Implement Tool: Develop the tool functionality according to the protocol
3. Register Tool: Use the API to register your tool with LYRAIOS
4. Use Tool: Your tool is now available for use by LYRAIOS agents

For examples and detailed documentation, see the Tool Integration Guide.

MCP Protocol Overview

Model Context Protocol (MCP) is a client-server architecture protocol for connecting LLM applications and integrations. In MCP:

- Hosts are LLM applications (such as Claude Desktop or IDE) that initiate connections
- Clients maintain a 1:1 connection with servers in host applications
- Servers provide context, tools, and prompts to clients

MCP Function Support

LYRAIOS supports the following MCP functions:

- Resources: Allow attaching local files and data
- Prompts: Support prompt templates
- Tools: Integrate to execute commands and scripts
- Sampling: Support sampling functions (planned)
- Roots: Support root directory functions (planned)

Data Flow

User Request Processing Flow

1. User sends request through the interface layer
2. Core OS layer receives the request and processes it
3. If external tool support is needed, the request is forwarded to the MCP integration layer
4. MCP client connects to the corresponding MCP server
5. External service executes the request and returns the result
6. The result is returned to the user through each layer

Tool Execution Flow

1. AI Agent determines that a specific tool is needed
2. Tool registry looks up tool definition and capabilities
3. Tool executor prepares execution environment
4. Adapter converts request to tool-understandable format
5. Tool executes and returns the result
6. The result is returned to the AI Agent for processing

Overview

LYRAIOS (LLM-based Your Reliable AI Operating System) is an advanced AI assistant platform built with Streamlit, designed to serve as an operating system for AI applications.

Core OS Features

- AI Process Management: - Dynamic task allocation and scheduling - Multi-assistant coordination and communication - Resource optimization and load balancing - State management and persistence

- AI Memory System:
- Short-term conversation memory
- Long-term vector database storage
- Cross-session context preservation
- Knowledge base integration

- AI I/O System:
- Multi-modal input processing (text, files, APIs)
- Structured output formatting
- Stream processing capabilities
- Event-driven architecture

Built-in Tools

- Calculator: Advanced mathematical operations including factorial and prime number checking - Web Search: Integrated DuckDuckGo search with customizable result limits - Financial Analysis: - Real-time stock price tracking - Company information retrieval - Analyst recommendations - Financial news aggregation - File Management: Read, write, and list files in the workspace - Research Tools: Integration with Exa for comprehensive research capabilities

Specialized Assistant Team

- Python Assistant: - Live Python code execution - Streamlit charting capabilities - Package management with pip - Research Assistant: - NYT-style report generation - Automated web research - Structured output formatting - Source citation and reference management

Technical Architecture

- FastAPI Backend: RESTful API with automatic documentation - Streamlit Frontend: Interactive web interface - Vector Database: PGVector for efficient knowledge storage and retrieval - PostgreSQL Storage: Persistent storage for conversations and assistant states - Docker Support: Containerized deployment for development and production

System Features

- Knowledge Management: - PDF document processing - Website content integration - Vector-based semantic search - Knowledge graph construction - Process Control: - Task scheduling and prioritization - Resource allocation - Error handling and recovery - Performance monitoring - Security & Access Control: - API key management - Authentication and authorization - Rate limiting and quota management - Secure data storage

Security Considerations

Transmission Security

- Use TLS for remote connections - Verify connection source - Implement authentication when needed

Message Validation

- Verify all incoming messages - Clean input - Check message size limits - Verify JSON-RPC format

Resource Protection

- Implement access control - Verify resource paths - Monitor resource usage - Limit request rate

Error Handling

- Do not leak sensitive information - Record security-related errors - Implement appropriate cleanup - Handle DoS scenarios

Roadmap 📍

Core Platform

- ✅ Basic AI Assistant Framework - ✅ Streamlit Web Interface - ✅ FastAPI Backend - ✅ Database Integration (SQLite/PostgreSQL) - ✅ OpenAI Integration - ✅ Docker Containerization - ✅ Environment Configuration System - 🔄 Multi-modal Input Processing (Partial) - 🚧 Advanced Error Handling & Recovery - 🚧 Performance Monitoring Dashboard - 📅 Distributed Task Queue - 📅 Horizontal Scaling Support - 📅 Custom Plugin Architecture

AI Process Management

- ✅ Basic Task Allocation - ✅ Multi-assistant Team Structure - ✅ State Management & Persistence - 🔄 Dynamic Task Scheduling (Partial) - 🚧 Resource Optimization - 🚧 Load Balancing - 📅 Process Visualization - 📅 Workflow Designer - 📅 Advanced Process Analytics

Memory System

- ✅ Short-term Conversation Memory - ✅ Basic Vector Database Integration - ✅ Session Context Preservation - 🔄 Knowledge Base Integration (Partial) - 🚧 Memory Optimization Algorithms - 🚧 Cross-session Learning - 📅 Hierarchical Memory Architecture - 📅 Forgetting Mechanisms - 📅 Memory Compression

Tools & Integrations

- ✅ Calculator - ✅ Web Search (DuckDuckGo) - ✅ Financial Analysis Tools - ✅ File Management - ✅ Research Tools (Exa) - ✅ PDF Document Processing - ✅ Website Content Integration - 🔄 Python Code Execution (Partial) - 🚧 Advanced Data Visualization - 🚧 External API Integration Framework - 📅 Image Generation & Processing - 📅 Audio Processing - 📅 Video Analysis

Security & Access Control

- ✅ Basic API Key Management - ✅ Simple Authentication - 🔄 Authorization System (Partial) - 🚧 Rate Limiting - 🚧 Quota Management - 📅 Role-based Access Control - 📅 Audit Logging - 📅 Compliance Reporting

Open Protocol Architecture

- 🔄 Module Interface Standards (Partial) - 🚧 Third-party Tool Integration Protocol - 🚧 Service Discovery Mechanism - 📅 Universal Connector Framework - 📅 Protocol Validation System - 📅 Compatibility Layer for Legacy Systems

Multi-Agent Collaboration

- ✅ Basic Team Structure - 🔄 Inter-agent Communication (Partial) - 🚧 Task Decomposition Engine - 🚧 Conflict Resolution System - 📅 Collaborative Planning - 📅 Emergent Behavior Analysis - 📅 Agent Specialization Framework

Cross-Platform Support

- ✅ Web Interface - 🔄 API Access (Partial) - 🚧 Mobile Responsiveness - 📅 Desktop Application - 📅 CLI Interface - 📅 IoT Device Integration - 📅 Voice Assistant Integration

Legend

- ✅ Completed - 🔄 Partially Implemented - 🚧 In Development - 📅 Planned

Setup Workspace

```sh

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

LYRAIOS

Overview & Technical Foundation

Core Innovations & Differentiated Value

System Architecture

User Interface Layer

Components:

Core OS Layer

Components:

MCP Integration Layer

Components:

External Services Layer

Components:

Tool Integration Protocol

Key Features

Getting Started with Tool Integration

MCP Protocol Overview

MCP Function Support

Data Flow

User Request Processing Flow

Tool Execution Flow

Overview

Core OS Features

Built-in Tools

Specialized Assistant Team

Technical Architecture

System Features

Security Considerations

Transmission Security

Message Validation

Resource Protection

Error Handling

Roadmap 📍

Core Platform

AI Process Management

Memory System

Tools & Integrations

Security & Access Control

Open Protocol Architecture

Multi-Agent Collaboration

Cross-Platform Support

Legend

Setup Workspace

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Reactive Resume

FastMCP v2 🚀