Skip to content
Back to search

lyraios

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 blockchain public chain operations (SOLANA,ETH,BSC,etc.)

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/galaxyllmci--lyraios/badge.svg)](/listings/galaxyllmci--lyraios)

HTML

<a href="/listings/galaxyllmci--lyraios"><img src="/api/listings/galaxyllmci--lyraios/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# Clone the repo
git clone https://github.com/GalaxyLLMCI/lyraios
cd lyraios

# Create + activate a virtual env
python3 -m venv aienv
source aienv/bin/activate

# Install phidata
pip install 'phidata[aws]'

# Setup workspace
phi ws setup

# Copy example secrets
cp workspace/example_secrets workspace/secrets

# Create .env file
cp example.env .env

# Run Lyraios locally
phi ws up

# Open [localhost:8501](http://localhost:8501) to view the Streamlit App.

# Stop Lyraios locally
phi ws down

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 700 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # LYRAIOS
  2. ## Overview & Technical Foundation
  3. 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.
  4. > In the future operation of LYRAIOS, advanced VIP features will exclusively support payment using LYRAI on solana, with LYRAI's CA : `A6MTWuHbXqjH3vYEfbs3mzvGThQtk5S12FjmdpVkpump`
  5. **Welcome to check out the demo of our LYRA MCP-OS!**
  6. https://github.com/user-attachments/assets/479cad58-ce4b-4901-93ff-e60a98c477d4
  7. ## Core Innovations & Differentiated Value
  8. LYRAIOS aims to create the next generation AI Agent operating system with technological breakthroughs in three dimensions:
  9. 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
  10. 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
  11. 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
  12. For detailed architecture information, see the [Architecture Documentation](docs/ARCHITECTURE.md).
  13. ## System Architecture
  14. 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.
  15. ![LYRAIOS Architecture](docs/lyraios-architecture.jpg)
  16. <p align="center">
  17. VS
  18. </p>
  19. ![MANUS Architecture](docs/manus-architecture.png)
  20. ### User Interface Layer
  21. The user interface layer provides multiple interaction modes, allowing users to interact with the AI OS.
  22. #### Components:
  23. - **Web UI**: Based on Streamlit, providing an intuitive user interface
  24. - **Mobile UI**: Mobile adaptation interface, supporting mobile device access
  25. - **CLI**: Command line interface, suitable for developers and advanced users
  26. - **API Clients**: Provide API interfaces, supporting third-party application integration
  27. ### Core OS Layer
  28. The core OS layer implements the basic functions of the AI operating system, including process management, memory system, I/O system, and security control.
  29. #### Components:
  30. - **Process Management**
  31. - Task Scheduling: Dynamic allocation and scheduling of AI tasks
  32. - Resource Allocation: Optimize AI resource usage
  33. - State Management: Maintain AI process state
  34. - **Memory System**
  35. - Short-term Memory: Session context maintenance
  36. - Long-term Storage: Persistent knowledge storage
  37. - Knowledge Base: Structured knowledge management
  38. - **I/O System**
  39. - Multi-modal Input: Handle text, files, APIs, etc.
  40. - Structured Output: Generate formatted output results
  41. - Event Handling: Respond to system events
  42. - **Security & Access Control**
  43. - Authentication: User authentication
  44. - Authorization: Permission management
  45. - Rate Limiting: Prevent abuse
  46. ### MCP Integration Layer
  47. MCP Integration Layer is the core innovation of the system, achieving seamless integration with external services through the Model Context Protocol.
  48. #### Components:
  49. - **MCP Client**
  50. - Protocol Handler: Process MCP protocol messages
  51. - Connection Management: Manage connections to MCP servers
  52. - Message Routing: Route messages to appropriate processors
  53. - **Tool Registry**
  54. - Tool Registration: Register external tools and services
  55. - Capability Discovery: Discover tool capabilities
  56. - Manifest Validation: Validate tool manifests
  57. - **Tool Executor**
  58. - Execution Environment: Provide an execution environment for tool execution
  59. - Resource Management: Manage the resources used by tool execution
  60. - Error Handling: Handle errors during tool execution
  61. - **Adapters**
  62. - REST API Adapter: Connect to REST API services
  63. - Python Plugin Adapter: Integrate Python plugins
  64. - Custom Adapter: Support other types of integration
  65. ### External Services Layer
  66. The external services layer includes various services integrated through the MCP protocol, which act as MCP servers providing capabilities.
  67. #### Components:
  68. - **File System**: Provide file read and write capabilities
  69. - **Database**: Provide data storage and query capabilities
  70. - **Web Search**: Provide internet search capabilities
  71. - **Code Editor**: Provide code editing and execution capabilities
  72. - **Browser**: Provide web browsing and interaction capabilities
  73. - **Custom Services**: Support other custom services integration
  74. ## Tool Integration Protocol
  75. 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.
  76. ### Key Features
  77. - **Standardized Tool Manifest**: Define tools using a JSON schema that describes capabilities, parameters, and requirements
  78. - **Pluggable Adapter System**: Support for different tool types (REST API, Python plugins, etc.)
  79. - **Secure Execution Environment**: Tools run in a controlled environment with resource limits and permission checks
  80. - **Versioning and Dependency Management**: Track tool versions and dependencies
  81. - **Monitoring and Logging**: Comprehensive logging of tool execution
  82. ### Getting Started with Tool Integration
  83. 1. **Define Tool Manifest**: Create a JSON file describing your tool's capabilities
  84. 2. **Implement Tool**: Develop the tool functionality according to the protocol
  85. 3. **Register Tool**: Use the API to register your tool with LYRAIOS
  86. 4. **Use Tool**: Your tool is now available for use by LYRAIOS agents
  87. For examples and detailed documentation, see the [Tool Integration Guide](docs/tool_integration.md).
  88. ## MCP Protocol Overview
  89. Model Context Protocol (MCP) is a client-server architecture protocol for connecting LLM applications and integrations. In MCP:
  90. - **Hosts** are LLM applications (such as Claude Desktop or IDE) that initiate connections
  91. - **Clients** maintain a 1:1 connection with servers in host applications
  92. - **Servers** provide context, tools, and prompts to clients
  93. ### MCP Function Support
  94. LYRAIOS supports the following MCP functions:
  95. - **Resources**: Allow attaching local files and data
  96. - **Prompts**: Support prompt templates
  97. - **Tools**: Integrate to execute commands and scripts
  98. - **Sampling**: Support sampling functions (planned)
  99. - **Roots**: Support root directory functions (planned)
  100. ## Data Flow
  101. ### User Request Processing Flow
  102. 1. User sends request through the interface layer
  103. 2. Core OS layer receives the request and processes it
  104. 3. If external tool support is needed, the request is forwarded to the MCP integration layer
  105. 4. MCP client connects to the corresponding MCP server
  106. 5. External service executes the request and returns the result
  107. 6. The result is returned to the user through each layer
  108. ### Tool Execution Flow
  109. 1. AI Agent determines that a specific tool is needed
  110. 2. Tool registry looks up tool definition and capabilities
  111. 3. Tool executor prepares execution environment
  112. 4. Adapter converts request to tool-understandable format
  113. 5. Tool executes and returns the result
  114. 6. The result is returned to the AI Agent for processing
  115. ## Overview
  116. 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.
  117. ### Core OS Features
  118. - **AI Process Management**:
  119. - Dynamic task allocation and scheduling
  120. - Multi-assistant coordination and communication
  121. - Resource optimization and load balancing
  122. - State management and persistence
  123. - **AI Memory System**:
  124. - Short-term conversation memory
  125. - Long-term vector database storage
  126. - Cross-session context preservation
  127. - Knowledge base integration
  128. - **AI I/O System**:
  129. - Multi-modal input processing (text, files, APIs)
  130. - Structured output formatting
  131. - Stream processing capabilities
  132. - Event-driven architecture
  133. ### Built-in Tools
  134. - **Calculator**: Advanced mathematical operations including factorial and prime number checking
  135. - **Web Search**: Integrated DuckDuckGo search with customizable result limits
  136. - **Financial Analysis**:
  137. - Real-time stock price tracking
  138. - Company information retrieval
  139. - Analyst recommendations
  140. - Financial news aggregation
  141. - **File Management**: Read, write, and list files in the workspace
  142. - **Research Tools**: Integration with Exa for comprehensive research capabilities
  143. ### Specialized Assistant Team
  144. - **Python Assistant**:
  145. - Live Python code execution
  146. - Streamlit charting capabilities
  147. - Package management with pip
  148. - **Research Assistant**:
  149. - NYT-style report generation
  150. - Automated web research
  151. - Structured output formatting
  152. - Source citation and reference management
  153. ### Technical Architecture
  154. - **FastAPI Backend**: RESTful API with automatic documentation
  155. - **Streamlit Frontend**: Interactive web interface
  156. - **Vector Database**: PGVector for efficient knowledge storage and retrieval
  157. - **PostgreSQL Storage**: Persistent storage for conversations and assistant states
  158. - **Docker Support**: Containerized deployment for development and production
  159. ### System Features
  160. - **Knowledge Management**:
  161. - PDF document processing
  162. - Website content integration
  163. - Vector-based semantic search
  164. - Knowledge graph construction
  165. - **Process Control**:
  166. - Task scheduling and prioritization
  167. - Resource allocation
  168. - Error handling and recovery
  169. - Performance monitoring
  170. - **Security & Access Control**:
  171. - API key management
  172. - Authentication and authorization
  173. - Rate limiting and quota management
  174. - Secure data storage
  175. ## Security Considerations
  176. ### Transmission Security
  177. - Use TLS for remote connections
  178. - Verify connection source
  179. - Implement authentication when needed
  180. ### Message Validation
  181. - Verify all incoming messages
  182. - Clean input
  183. - Check message size limits
  184. - Verify JSON-RPC format
  185. ### Resource Protection
  186. - Implement access control
  187. - Verify resource paths
  188. - Monitor resource usage
  189. - Limit request rate
  190. ### Error Handling
  191. - Do not leak sensitive information
  192. - Record security-related errors
  193. - Implement appropriate cleanup
  194. - Handle DoS scenarios
  195. ## Roadmap 📍
  196. ### Core Platform
  197. - ✅ Basic AI Assistant Framework
  198. - ✅ Streamlit Web Interface
  199. - ✅ FastAPI Backend
  200. - ✅ Database Integration (SQLite/PostgreSQL)
  201. - ✅ OpenAI Integration
  202. - ✅ Docker Containerization
  203. - ✅ Environment Configuration System
  204. - 🔄 Multi-modal Input Processing (Partial)
  205. - 🚧 Advanced Error Handling & Recovery
  206. - 🚧 Performance Monitoring Dashboard
  207. - 📅 Distributed Task Queue
  208. - 📅 Horizontal Scaling Support
  209. - 📅 Custom Plugin Architecture
  210. ### AI Process Management
  211. - ✅ Basic Task Allocation
  212. - ✅ Multi-assistant Team Structure
  213. - ✅ State Management & Persistence
  214. - 🔄 Dynamic Task Scheduling (Partial)
  215. - 🚧 Resource Optimization
  216. - 🚧 Load Balancing
  217. - 📅 Process Visualization
  218. - 📅 Workflow Designer
  219. - 📅 Advanced Process Analytics
  220. ### Memory System
  221. - ✅ Short-term Conversation Memory
  222. - ✅ Basic Vector Database Integration
  223. - ✅ Session Context Preservation
  224. - 🔄 Knowledge Base Integration (Partial)
  225. - 🚧 Memory Optimization Algorithms
  226. - 🚧 Cross-session Learning
  227. - 📅 Hierarchical Memory Architecture
  228. - 📅 Forgetting Mechanisms
  229. - 📅 Memory Compression
  230. ### Tools & Integrations
  231. - ✅ Calculator
  232. - ✅ Web Search (DuckDuckGo)
  233. - ✅ Financial Analysis Tools
  234. - ✅ File Management
  235. - ✅ Research Tools (Exa)
  236. - ✅ PDF Document Processing
  237. - ✅ Website Content Integration
  238. - 🔄 Python Code Execution (Partial)
  239. - 🚧 Advanced Data Visualization
  240. - 🚧 External API Integration Framework
  241. - 📅 Image Generation & Processing
  242. - 📅 Audio Processing
  243. - 📅 Video Analysis
  244. ### Security & Access Control
  245. - ✅ Basic API Key Management
  246. - ✅ Simple Authentication
  247. - 🔄 Authorization System (Partial)
  248. - 🚧 Rate Limiting
  249. - 🚧 Quota Management
  250. - 📅 Role-based Access Control
  251. - 📅 Audit Logging
  252. - 📅 Compliance Reporting
  253. ### Open Protocol Architecture
  254. - 🔄 Module Interface Standards (Partial)
  255. - 🚧 Third-party Tool Integration Protocol
  256. - 🚧 Service Discovery Mechanism
  257. - 📅 Universal Connector Framework
  258. - 📅 Protocol Validation System
  259. - 📅 Compatibility Layer for Legacy Systems
  260. ### Multi-Agent Collaboration
  261. - ✅ Basic Team Structure
  262. - 🔄 Inter-agent Communication (Partial)
  263. - 🚧 Task Decomposition Engine
  264. - 🚧 Conflict Resolution System
  265. - 📅 Collaborative Planning
  266. - 📅 Emergent Behavior Analysis
  267. - 📅 Agent Specialization Framework
  268. ### Cross-Platform Support
  269. - ✅ Web Interface
  270. - 🔄 API Access (Partial)
  271. - 🚧 Mobile Responsiveness
  272. - 📅 Desktop Application
  273. - 📅 CLI Interface
  274. - 📅 IoT Device Integration
  275. - 📅 Voice Assistant Integration
  276. ### Legend
  277. - ✅ Completed
  278. - 🔄 Partially Implemented
  279. - 🚧 In Development
  280. - 📅 Planned
  281. ## Setup Workspace
  282. ```sh
  283. # Clone the repo
  284. git clone https://github.com/GalaxyLLMCI/lyraios
  285. cd lyraios
  286. # Create + activate a virtual env
  287. python3 -m venv aienv
  288. source aienv/bin/activate
  289. # Install phidata
  290. pip install 'phidata[aws]'
  291. # Setup workspace
  292. phi ws setup
  293. # Copy example secrets
  294. cp workspace/example_secrets workspace/secrets
  295. # Create .env file
  296. cp example.env .env
  297. # Run Lyraios locally
  298. phi ws up
  299. # Open [localhost:8501](http://localhost:8501) to view the Streamlit App.
  300. # Stop Lyraios locally
  301. phi ws down
  302. ```
  303. ## Run Lyraios locally
  304. 1. Install [docker desktop](https://www.docker.com/products/docker-desktop)
  305. 2. Export credentials
  306. We use gpt-4o as the LLM, so export your OpenAI API Key
  307. ```sh
  308. export OPENAI_API_KEY=sk-***
  309. # To use Exa for research, export your EXA_API_KEY (get it from [here](https://dashboard.exa.ai/api-keys))
  310. export EXA_API_KEY=xxx
  311. # To use Gemini for research, export your GOOGLE_API_KEY (get it from [here](https://console.cloud.google.com/apis/api/generativelanguage.googleapis.com/overview?project=lyraios))
  312. export GOOGLE_API_KEY=xxx
  313. # OR set them in the `.env` file
  314. OPENAI_API_KEY=xxx
  315. EXA_API_KEY=xxx
  316. GOOGLE_API_KEY=xxx
  317. # Start the workspace using:
  318. phi ws up
  319. # Open [localhost:8501](http://localhost:8501) to view the Streamlit App.
  320. # Stop the workspace using:
  321. phi ws down
  322. ```
  323. ## API Documentation
  324. ### REST API Endpoints
  325. #### Assistant API
  326. - `POST /api/v1/assistant/chat`
  327. - Process chat messages with the AI assistant
  328. - Supports context-aware conversations
  329. - Returns structured responses with tool usage information
  330. #### Health Check
  331. - `GET /api/v1/health`
  332. - Monitor system health status
  333. - Returns version and status information
  334. ### API Documentation
  335. - Interactive API documentation available at `/docs`
  336. - ReDoc alternative documentation at `/redoc`
  337. - OpenAPI specification at `/openapi.json`
  338. ## Development Guide
  339. ### Project Structure
  340. ```
  341. lyraios/
  342. ├── ai/ # AI core functionality
  343. │ ├── assistants.py # Assistant implementations
  344. │ ├── llm/ # LLM integration
  345. │ └── tools/ # AI tools implementations
  346. ├── app/ # Main application
  347. │ ├── components/ # UI components
  348. │ ├── config/ # Application configuration
  349. │ ├── db/ # Database models and storage
  350. │ ├── styles/ # UI styling
  351. │ ├── utils/ # Utility functions
  352. │ └── main.py # Main application entry point
  353. ├── assets/ # Static assets like images
  354. ├── data/ # Data storage
  355. ├── tests/ # Test suite
  356. ├── workspace/ # Workspace configuration
  357. │ ├── dev_resources/ # Development resources
  358. │ ├── settings.py # Workspace settings
  359. │ └── secrets/ # Secret configuration (gitignored)
  360. ├── docker/ # Docker configuration
  361. ├── scripts/ # Utility scripts
  362. ├── .env # Environment variables
  363. ├── requirements.txt # Python dependencies
  364. └── README.md # Project documentation
  365. ```
  366. ### Environment Configuration
  367. 1. **Environment Variables Setup**
  368. ```bash
  369. # Copy the example .env file
  370. cp example.env .env
  371. # Required environment variables
  372. EXA_API_KEY=your_exa_api_key_here # Get from https://dashboard.exa.ai/api-keys
  373. OPENAI_API_KEY=your_openai_api_key_here # Get from OpenAI dashboard
  374. OPENAI_BASE_URL=your_openai_base_url # Optional: Custom OpenAI API endpoint
  375. # OpenAI Model Configuration
  376. OPENAI_CHAT_MODEL=gpt-4-turbo-preview # Default chat model
  377. OPENAI_VISION_MODEL=gpt-4-vision-preview # Model for vision tasks
  378. OPENAI_EMBEDDING_MODEL=text-embedding-3-small # Model for embeddings
  379. # Optional configuration
  380. STREAMLIT_SERVER_PORT=8501 # Default Streamlit port
  381. API_SERVER_PORT=8000 # Default FastAPI port
  382. ```
  383. 2. **OpenAI Configuration Examples**
  384. ```bash
  385. # Standard OpenAI API
  386. OPENAI_API_KEY=sk-***
  387. OPENAI_BASE_URL=https://api.openai.com/v1
  388. OPENAI_CHAT_MODEL=gpt-4-turbo-preview
  389. # Azure OpenAI
  390. OPENAI_API_KEY=your_azure_api_key
  391. OPENAI_BASE_URL=https://your-resource.openai.azure.com/openai/deployments/your-deployment
  392. OPENAI_CHAT_MODEL=gpt-4
  393. # Other OpenAI API providers
  394. OPENAI_API_KEY=your_api_key
  395. OPENAI_BASE_URL=https://your-api-endpoint.com/v1
  396. OPENAI_CHAT_MODEL=your-model-name
  397. ```
  398. 2. **Streamlit Configuration**
  399. ```bash
  400. # Create Streamlit config directory
  401. mkdir -p ~/.streamlit
  402. # Create config.toml to disable usage statistics (optional)
  403. cat > ~/.streamlit/config.toml << EOL
  404. [browser]
  405. gatherUsageStats = false
  406. EOL
  407. ```
  408. ### Development Scripts
  409. The project includes convenient development scripts to manage the application:
  410. 1. **Using dev.py Script**
  411. ```bash
  412. # Run both frontend and backend
  413. python -m scripts.dev run
  414. # Run only frontend
  415. python -m scripts.dev run --no-backend
  416. # Run only backend
  417. python -m scripts.dev run --no-frontend
  418. # Run with custom ports
  419. python -m scripts.dev run --frontend-port 8502 --backend-port 8001
  420. ```
  421. 2. **Manual Service Start**
  422. ```bash
  423. # Start Streamlit frontend
  424. streamlit run app/app.py
  425. # Start FastAPI backend
  426. uvicorn api.main:app --reload
  427. ```
  428. ### Dependencies Management
  429. 1. **Core Dependencies**
  430. ```bash
  431. # Install production dependencies
  432. pip install -r requirements.txt
  433. # Install development dependencies
  434. pip install -r requirements-dev.txt
  435. # Install the project in editable mode
  436. pip install -e .
  437. ```
  438. 2. **Additional Tools**
  439. ```bash
  440. # Install python-dotenv for environment management
  441. pip install python-dotenv
  442. # Install development tools
  443. pip install black isort mypy pytest
  444. ```
  445. ### Development Best Practices
  446. 1. **Code Style**
  447. - Follow PEP 8 guidelines
  448. - Use type hints
  449. - Write docstrings for functions and classes
  450. - Use black for code formatting
  451. - Use isort for import sorting
  452. 2. **Testing**
  453. ```bash
  454. # Run tests
  455. pytest
  456. # Run tests with coverage
  457. pytest --cov=app tests/
  458. ```
  459. 3. **Pre-commit Hooks**
  460. ```bash
  461. # Install pre-commit hooks
  462. pre-commit install
  463. # Run manually
  464. pre-commit run --all-files
  465. ```
  466. ### Deployment Guide
  467. #### Docker Deployment
  468. 1. **Development Environment**
  469. ```bash
  470. # Build development image
  471. docker build -f docker/Dockerfile.dev -t lyraios:dev .
  472. # Run development container
  473. docker-compose -f docker-compose.dev.yml up
  474. ```
  475. 2. **Production Environment**
  476. ```bash
  477. # Build production image
  478. docker build -f docker/Dockerfile.prod -t lyraios:prod .
  479. # Run production container
  480. docker-compose -f docker-compose.prod.yml up -d
  481. ```
  482. #### Configuration Options
  483. 1. **Environment Variables**
  484. ```
  485. # Application Settings
  486. DEBUG=false
  487. LOG_LEVEL=INFO
  488. ALLOWED_HOSTS=example.com,api.example.com
  489. # AI Settings
  490. AI_MODEL=gpt-4
  491. AI_TEMPERATURE=0.7
  492. AI_MAX_TOKENS=1000
  493. # Database Settings
  494. DATABASE_URL=postgresql://user:pass@localhost:5432/dbname
  495. ```
  496. 2. **Scaling Options**
  497. - Configure worker processes via `GUNICORN_WORKERS`
  498. - Adjust memory limits via `MEMORY_LIMIT`
  499. - Set concurrency via `MAX_CONCURRENT_REQUESTS`
  500. ### Monitoring and Maintenance
  501. 1. **Health Checks**
  502. - Monitor `/health` endpoint
  503. - Check system metrics via Prometheus endpoints
  504. - Review logs in `/var/log/lyraios/`
  505. 2. **Backup and Recovery**
  506. ```bash
  507. # Backup database
  508. python scripts/backup_db.py
  509. # Restore from backup
  510. python scripts/restore_db.py --backup-file backup.sql
  511. ```
  512. 3. **Troubleshooting**
  513. - Check application logs
  514. - Verify environment variables
  515. - Ensure database connectivity
  516. - Monitor system resources
  517. ### Database Configuration
  518. The system supports both SQLite and PostgreSQL databases:
  519. 1. **SQLite (Default)**
  520. ```bash
  521. # SQLite Configuration
  522. DATABASE_TYPE=sqlite
  523. DATABASE_PATH=data/lyraios.db
  524. ```
  525. 2. **PostgreSQL**
  526. ```bash
  527. # PostgreSQL Configuration
  528. DATABASE_TYPE=postgres
  529. POSTGRES_HOST=localhost
  530. POSTGRES_PORT=5432
  531. POSTGRES_DB=lyraios
  532. POSTGRES_USER=postgres
  533. POSTGRES_PASSWORD=your_password
  534. ```
  535. The system will automatically use SQLite if no PostgreSQL configuration is provided.
  536. ## Contributing
  537. We welcome contributions! Please see the [CONTRIBUTING.md](CONTRIBUTING.md) file for details.
  538. ## License
  539. This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.