RIGEL MCP工具

Voice Requirements

System Dependencies

```bash

Define messages that require tool usage

messages = [ ("system", "You are RIGEL with access to system tools. Use them when appropriate."), ("human", "What time is it and what files are in the current directory?"), ]

Installation

1. Clone the repository:

git clone <repository-url>
cd RIGEL

1. For D-Bus integration, install the system D-Bus configuration:

sudo bash install_dbus_config.sh

This script installs the rigel-dbus.conf configuration into /etc/dbus-1/system.d/ and reloads D-Bus.

1. If you prefer manual setup, create a Python virtual environment and install dependencies:

```bash python -m venv .venv source .venv/bin/activate # On Linux/macOS

Install Piper TTS (for voice synthesis)

Or install via package manager if available

Install PulseAudio for audio playback (Ubuntu/Debian)

sudo apt-get install pulseaudio pulseaudio-utils

Install PulseAudio for audio playback (Fedora/RHEL)

sudo dnf install pulseaudio pulseaudio-utils

Install SDL2 for live voice recognition with whisper-stream

sudo apt-get install libsdl2-2.0-0 # Ubuntu/Debian sudo dnf install SDL2 # Fedora/RHEL

5. For Ollama backend, ensure Ollama is installed and running:

Install Ollama (if not already installed)

curl -fsSL https://ollama.ai/install.sh | sh

Docker Compose (Recommended)

Before starting RIGEL, install dependencies and prepare the host environment. If you need Linux D-Bus integration, run the provided D-Bus installer script first:

sudo bash install_dbus_config.sh

Then start RIGEL with Docker Compose:

docker compose up

This will start RIGEL in a consistent containerized environment with sane defaults and easy server selection via SERVER_TYPE.

Install Piper TTS

Install PulseAudio for audio playback

sudo apt-get install pulseaudio pulseaudio-utils # Ubuntu/Debian sudo dnf install pulseaudio pulseaudio-utils # Fedora/RHEL

Install SDL2 for live voice recognition (whisper-stream audio capture)

sudo apt-get install libsdl2-2.0-0 # Ubuntu/Debian sudo dnf install SDL2 # Fedora/RHEL ```

Python Dependencies

Voice features require additional dependencies included in requirements.txt:

• openai-whisper: For speech recognition
• torch, torchaudio, torchvision: PyTorch dependencies for Whisper

Voice Models

• Piper Models: .onnx voice models stored in core/synthesis_assets/. Default: knight.onnx. Set VOICE env var to select a different model (e.g. VOICE=hal).
• Whisper Models (Python): Downloaded automatically when first used
• Whisper.cpp Models (ggml): Pre-bundled in core/whisper_live/models/ for live recognition

MCP Setup Instructions

When you first run RIGEL without MCP server configuration, you'll see this message:

Open server.py and add your custom mcp servers here before initializing
There is a basic mcp server built in inside core/mcp/rigel_tools_server.py
You can start it by typing
python core/mcp/rigel_tools_server.py

To set up MCP functionality:

1. For basic functionality: Start the built-in MCP server in a separate terminal:

   python core/mcp/rigel_tools_server.py
   

1. For advanced functionality: Edit server.py to configure multiple MCP servers:

• Uncomment the default_mcp = MultiServerMCPClient(...) section
• Modify server configurations to match your setup
• Add additional MCP servers as needed

1. Restart RIGEL to load the new MCP configuration

MCP Security Notes

• All file operations respect system permissions
• Commands are executed in a controlled environment
• Sensitive operations require explicit user intent
• Error handling prevents system damage

Example Tool built using RIGEL Engine

Quick Start

RIGEL offers two server modes to suit different use cases and environments:

Live voice recognition via WebSocket (JavaScript example in browser console or Node.js)

Quick Start

```bash

Use Cases

1. Daily Tasks: Automate repetitive browser operations
2. Testing: Create test scenarios and run them repeatedly
3. Monitoring: Check website status or data periodically
4. Data Collection: Gather information on a schedule

Example Workflow Creation

```bash

Basic Usage with Ollama

```python from core.rigel import RigelOllama

Basic Usage with Groq

```python from core.rigel import RigelGroq import os

Usage with Memory

```python from core.rigel import RigelOllama

Example MCP server configuration in server.py

default_mcp = MultiServerMCPClient( { "rigel tools": { "url": "http://localhost:8001/sse", "transport": "sse", }, "python-toolbox": { "command": "/path/to/your/mcp_server/.venv/bin/python", "args": [ "-m", "mcp_server_package", "--workspace", "/path/to/workspace" ], "env": { "PYTHONPATH": "/path/to/your/mcp_server/src", "PATH": "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin", "VIRTUAL_ENV": "/path/to/your/mcp_server/.venv", "PYTHONHOME": "" }, "transport": "stdio" } }, )

#### MCP Transport Types

RIGEL supports two MCP transport methods:

- **SSE (Server-Sent Events)**: For HTTP-based MCP servers

  

- **STDIO**: For process-based MCP servers
  

#### MCP Server Network Configuration

The built-in MCP server runs on **port 8001** by default using Server-Sent Events (SSE) transport:

MCP Usage Examples

Through D-Bus Service (Recommended)

```python from pydbus import SessionBus

bus = SessionBus() service = bus.get("com.rigel.RigelService")

D-Bus Client Examples

Basic Client Setup

from pydbus import SessionBus

bus = SessionBus()
service = bus.get("com.rigel.RigelService")

Advanced Usage Patterns

```python

Core + optional voice asset locator package

pip install "rigel-engine-core[voice-assets]"

4. For voice features, install system dependencies:

Select option 1

Select option 2

In .env or environment

VOICE=knight # Options: knight, hal, jarvis-medium

#### Switching Voices via API

MCP Server Configuration

RIGEL supports multiple MCP servers through the MultiServerMCPClient. You can configure custom MCP servers in server.py before initialization.

Built-in MCP Server

RIGEL includes a built-in MCP server with essential system tools. This server must be started separately from the main RIGEL process.

```bash

Default configuration in server.py

"rigel tools": { "url": "http://localhost:8001/sse", "transport": "sse", } ```

To change the port, modify both:

1. core/mcp/rigel_tools_server.py: Update the port=8001 parameter in FastMCP()
2. server.py: Update the URL in the MCP client configuration

Adding Your Own MCP Server

1. Create your MCP server following the MCP specification
2. Edit server.py and add your server to the MultiServerMCPClient configuration
3. Set default_mcp to your configuration instead of None
4. Restart the RIGEL service to load the new configuration

If no MCP servers are configured (default_mcp = None), RIGEL will display a warning message suggesting you configure MCP servers for enhanced functionality.

MCP Troubleshooting

Common Issues:

1. "MCP server connection failed"

• Ensure the MCP server is running before starting RIGEL
• Check that port 8001 is available and not blocked by firewall
• Verify the URL in the configuration matches the server

1. "QueryWithTools times out"

• Commands have a 30-second timeout for safety
• Check if the requested operation is resource-intensive
• Verify system commands are valid and accessible

1. "Permission denied" errors

• MCP tools respect system file permissions
• Ensure RIGEL has appropriate access to requested files/directories
• Check user permissions for system commands

4. MCP tools not available - Verify default_mcp is properly configured in server.py - Ensure MCP dependencies are installed: pip install langchain_mcp_adapters - Check that the MCP server started successfully

Web Server (HTTP REST API)

RIGEL's web server provides a REST API interface accessible from any HTTP client, with automatic OpenAPI documentation.

Best for:

• Cross-platform compatibility
• Remote access
• Web applications
• Mobile app backends
• API integrations

Starting the Web Server

```bash

const ws = new WebSocket("ws://localhost:8000/live-voice-recognition?api_key=rigel_your_key");

D-Bus Voice Endpoints

SynthesizeText(text: str, mode: str, voice: str) -> str

• Description: Converts text to speech with specified synthesis mode and optional voice override
• Parameters:
• text - The text to synthesize
• mode - Synthesis mode: "chunk" or "linear"
• voice - (Optional) Voice model name to use (e.g. "knight", "hal"). Empty string uses default.
• Returns: Status message indicating synthesis queued
• Use Case: Voice output for AI responses, notifications, accessibility

ListVoices() -> str

• Description: Returns a JSON string with available voice model names and the currently active voice
• Returns: JSON string: {"voices": ["hal", "jarvis-medium", "knight"], "current": "knight"}
• Use Case: Discover available TTS voices, check current voice

SetVoice(voice_name: str) -> str

• Description: Switch the active voice synthesis model
• Parameters:
• voice_name - Name of the voice model (e.g. "hal", "knight")
• Returns: Status message confirming voice change
• Use Case: Change TTS voice at runtime without restarting

CloneVoice(mp3_path: str, voice_name: str, language: str) -> str

• Description: Start the voice cloning pipeline from an MP3 file. Runs asynchronously — returns immediately with task status.
• Parameters:
• mp3_path - Path to the source MP3 voice sample
• voice_name - Name for the cloned voice
• language - Language code (e.g. "English (U.S.)")
• Returns: JSON string with status, PID, and output directory
• Use Case: Create custom voice models from voice samples

RecognizeAudio(audio_file_path: str, model: str) -> str

• Description: Transcribes audio file to text using Whisper
• Parameters:
• audio_file_path - Path to audio file (WAV, MP3, etc.)
• model - Whisper model size: "tiny", "base", "small", "medium", "large"
• Returns: Transcribed text from audio
• Use Case: Voice input processing, audio transcription, accessibility

LiveVoiceRecognition(action: str, config_json: str) -> str

• Description: Start/stop/check live voice recognition using whisper.cpp streaming. Results are streamed via the TranscriptionUpdate signal — subscribe to com.rigel.RigelService.TranscriptionUpdate to receive live transcription lines.
• Parameters:
• action - One of: "start", "stop", "status", "transcribe_file"
• config_json - JSON string with config:
• For start: {"model": "tiny.en", "capture_device": -1, "threads": 8, "step": 500, "length": 5000}
• For transcribe_file: {"model": "tiny.en", "file_path": "/path/to/audio.wav"}
• Returns: JSON string with status/results (start/stop return immediately; transcription lines arrive via signal)
• Signal: TranscriptionUpdate(s: text) — emitted for each transcription line from whisper-stream
• Use Case: Real-time voice transcription from microphone, low-latency audio processing

API Reference

D-Bus Interface Details

• Service Name: com.rigel.RigelService
• Interface: com.rigel.RigelService
• Object Path: /com/rigel/RigelService

Available D-Bus Endpoints

Core Inference Endpoints

• Query(query: str) -> str

- Description: Performs basic inference with the configured backend - Parameters: query - The user's message/question - Returns: AI response as string - Use Case: Simple AI interactions without memory or tools - Example:

    response = service.Query("What is artificial intelligence?")
    

• QueryWithMemory(query: str, thread_id: str) -> str

- Description: Performs inference with persistent conversation memory - Parameters: - query - The user's message/question - thread_id - Unique identifier for conversation thread - Returns: AI response as string with full context awareness - Use Case: Multi-turn conversations with context retention - Example:

    response = service.QueryWithMemory("My name is Alice and I'm a developer", "user123")
    follow_up = service.QueryWithMemory("What do you know about me?", "user123")
    

• QueryThink(query: str) -> str

- Description: Performs advanced thinking/reasoning operations - Parameters: query - The problem or scenario requiring deep thought - Returns: AI reasoning response with detailed analysis - Use Case: Complex problem solving, analysis, and decision making - Example:

    response = service.QueryThink("I need to choose between two job offers. Help me think through this decision.")
    

- QueryWithTools(query: str) -> str - Description: Performs inference with full MCP (Model Context Protocol) tools support - Parameters: query - The user's message/question that may require system operations - Returns: AI response with tool execution results integrated - Use Case: System administration, file management, real-time information - Available Tools: - current_time() - Get current date and time - run_system_command(command) - Execute shell commands - read_file(path) - Read file contents - write_file(path, content) - Write content to files - list_directory(path) - List directory contents - get_system_info() - Get comprehensive system information - Example:

    response = service.QueryWithTools("What time is it?")
    response = service.QueryWithTools("List files in the current directory and read the README")
    response = service.QueryWithTools("Check system load and create a status report")
    

Lightweight core package (no bundled large voice binaries/models)

pip install rigel-engine-core

D-Bus Server (Linux Desktop Integration)

RIGEL's D-Bus server provides system-wide AI assistance with advanced tool capabilities, perfect for Linux desktop integration.

Best for:

• Linux desktop environments
• System-wide AI assistance
• Inter-process communication
• Desktop application integration

Starting the D-Bus Server

```bash

Browser Automation Workflows

RIGEL includes a powerful workflow system that allows you to save and replay browser automation tasks. Create a workflow once with the AI agent, then replay it unlimited times without needing AI processing.

List all saved workflows

python test_browser_agent_direct.py --list

Run a task with AI and save as workflow

python test_browser_agent_direct.py --save "Workflow Name" "your task description"

Replay a saved workflow (no AI needed!)

python test_browser_agent_direct.py --replay "Workflow Name"

Create a workflow for searching YouTube

python test_browser_agent_direct.py --save "YouTube Search" \ "go to youtube.com and search for 'AI tutorials'"

5. Save all steps as a reusable workflow

```

Replaying Workflows

```bash

Workflow Management

Workflows are stored as JSON files in the workflows/ directory:

workflows/
├── README.md                       # Technical documentation
├── Example_YouTube_Search.json     # Example workflow
└── Your_Workflow_Name.json         # Your saved workflows

For detailed usage, see WORKFLOW_GUIDE.md

Set your Groq API key

os.environ["GROQ_API_KEY"] = "your-groq-api-key-here"