### Install Project Dependencies

Source: https://github.com/xpressai/xaibo/tree/main/examples/google_calendar_example

Navigate to the example directory for Google Calendar and install the project's dependencies using pip. This command installs the project in editable mode.

```shell
cd examples/google_calendar_example
pip install -e .
```

--------------------------------

### No Authentication Setup Example

Source: https://context7_llms

Shows how to start the Xaibo server with multiple adapters and then test API endpoints without requiring an Authorization header, suitable for development environments.

```bash
python -m xaibo.server.web \
  --adapter xaibo.server.adapters.OpenAiApiAdapter \
  --adapter xaibo.server.adapters.McpApiAdapter
```

```curl
curl http://localhost:8000/openai/models
```

--------------------------------

### Xaibo MCP Server Setup Examples

Source: https://context7_llms

Provides examples for setting up and interacting with the Xaibo server as an MCP server, including authentication via API keys and making requests using curl.

```bash
# Start as MCP server only
python -m xaibo.server.web \
  --adapter xaibo.server.adapters.McpApiAdapter \
  --port 8000

# Start with API key authentication
python -m xaibo.server.web \
  --adapter xaibo.server.adapters.McpApiAdapter \
  --mcp-api-key your-secret-key \
  --port 8000

# Use with MCP client (no authentication)
curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}'

# Use with MCP client (with authentication)
curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-secret-key" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}'

```

--------------------------------

### Start SvelteKit Development Server

Source: https://github.com/XpressAI/xaibo/tree/main/ui

Starts the development server for the SvelteKit project after installing dependencies. The `--open` flag can be used to automatically open the application in a new browser tab.

```shell
npm run dev

# or start the server and open the app in a new browser tab
npm run dev -- --open
```

--------------------------------

### Xaibo Production Deployment Example

Source: https://context7_llms

Shows how to start the Xaibo production server with multiple adapters (OpenAI, MCP) and API key authentication, binding to all network interfaces.

```bash
# Start production server with API key authentication
python -m xaibo.server.web \
  --agent-dir ./production-agents \
  --host 0.0.0.0 \
  --port 8000 \
  --adapter xaibo.server.adapters.OpenAiApiAdapter \
  --adapter xaibo.server.adapters.McpApiAdapter \
  --openai-api-key "${CUSTOM_OPENAI_API_KEY}" \
  --mcp-api-key "${MCP_API_KEY}"

```

--------------------------------

### Setting Up Xaibo UI Development

Source: https://context7_llms

Steps to set up the Xaibo UI development environment. This includes navigating to the UI directory, installing dependencies using pnpm, and starting the development server.

```bash
# From the root xaibo directory
cd ui
pnpm install

# Start the development server
pnpm run dev
```

--------------------------------

### Bash Example Production Server Configuration

Source: https://context7_llms

Demonstrates setting environment variables for API keys and starting the Xaibo server with specific adapters and network configurations for production.

```bash
# Set environment variables
export CUSTOM_OPENAI_API_KEY="sk-prod-key-$(date +%s)"
export MCP_API_KEY="mcp-prod-key-$(date +%s)"

# Start server with authentication
python -m xaibo.server.web \
  --agent-dir ./production-agents \
  --adapter xaibo.server.adapters.OpenAiApiAdapter \
  --adapter xaibo.server.adapters.McpApiAdapter \
  --host 0.0.0.0 \
  --port 8000
```

--------------------------------

### Xaibo Development Workflow Example

Source: https://context7_llms

Demonstrates a typical development workflow for Xaibo, including project initialization, environment configuration with API keys, starting the development server, and testing with curl.

```bash
# 1. Initialize project
uvx xaibo init my_project
cd my_project

# 2. Configure environment
echo "OPENAI_API_KEY=sk-..."> .env

# 3. Start development server
uv run xaibo dev

# 4. Test with curl
curl -X POST http://127.0.0.1:9001/openai/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "example", "messages": [{"role": "user", "content": "Hello"}]}'

```

--------------------------------

### Example Configuration: Multi-Modal Memory Setup

Source: https://context7_llms

Configuration for a multi-modal memory system, employing HuggingFace embeddings with specific device and audio sampling rate configurations.

```yaml
modules:
  - module: xaibo.primitives.modules.memory.TokenChunker
    id: chunker

  - module: xaibo.primitives.modules.memory.HuggingFaceEmbedder
    id: embedder
    config:
      model_name: "microsoft/DialoGPT-medium"
      device: "cuda"
      audio_sampling_rate: 22050

  - module: xaibo.primitives.modules.memory.NumpyVectorIndex
    id: vector_index
    config:
      storage_dir: "./multimodal_memory"

  - module: xaibo.primitives.modules.memory.VectorMemory
    id: memory
```

--------------------------------

### Example Configuration: High-Performance Memory Setup

Source: https://context7_llms

Configuration for a high-performance memory setup, utilizing larger window sizes, OpenAI embeddings, and a dedicated storage directory for the vector index.

```yaml
modules:
  - module: xaibo.primitives.modules.memory.TokenChunker
    id: chunker
    config:
      window_size: 1024
      window_overlap: 100

  - module: xaibo.primitives.modules.memory.OpenAIEmbedder
    id: embedder
    config:
      model: "text-embedding-3-large"
      dimensions: 1536

  - module: xaibo.primitives.modules.memory.NumpyVectorIndex
    id: vector_index
    config:
      storage_dir: "./high_perf_memory"

  - module: xaibo.primitives.modules.memory.VectorMemory
    id: memory
```

--------------------------------

### Example Configuration: Basic Memory Setup

Source: https://context7_llms

A basic configuration for the memory system, setting up token chunking, sentence transformer embeddings, a numpy vector index, and the core vector memory module.

```yaml
modules:
  - module: xaibo.primitives.modules.memory.TokenChunker
    id: chunker
    config:
      window_size: 512
      window_overlap: 50

  - module: xaibo.primitives.modules.memory.SentenceTransformerEmbedder
    id: embedder
    config:
      model_name: "all-MiniLM-L6-v2"

  - module: xaibo.primitives.modules.memory.NumpyVectorIndex
    id: vector_index
    config:
      storage_dir: "./memory"

  - module: xaibo.primitives.modules.memory.VectorMemory
    id: memory

exchange:
  - module: memory
    protocol: ChunkingProtocol
    provider: chunker
  - module: memory
    protocol: EmbeddingProtocol
    provider: embedder
  - module: memory
    protocol: VectorIndexProtocol
    provider: vector_index
```

--------------------------------

### Install and Run CLI Tool with uv

Source: https://docs.astral.sh/uv/

Illustrates the process of installing a command-line tool, such as `ruff`, using `uv tool install`. It then shows how to verify the installation by running the tool with a version check command.

```shell
uv tool install ruff
Resolved 1 package in 6ms
Installed 1 package in 2ms
+ ruff==0.5.4
Installed 1 executable: ruff

ruff --version
ruff 0.5.4
```

--------------------------------

### Start Xaibo Dev Server

Source: https://github.com/xpressai/xaibo/tree/main/examples/livekit_example

Starts the Xaibo development server. This server provides a web interface for inspecting agent configurations and monitoring agent behavior.

```shell
uv run xaibo dev
```

--------------------------------

### Start LiveKit Agent

Source: https://github.com/xpressai/xaibo/tree/main/examples/livekit_example

Starts the LiveKit agent, which handles voice conversations for the Xaibo agent. It should be run in parallel with the Xaibo dev server.

```shell
uv run python agent.py dev
```

--------------------------------

### Install Multiple Python Versions with uv

Source: https://docs.astral.sh/uv/

Demonstrates how to install multiple Python versions simultaneously using the `uv python install` command. The output shows the search process for each version and lists the successfully installed Python distributions.

```shell
uv python install 3.10 3.11 3.12
Searching for Python versions matching: Python 3.10
Searching for Python versions matching: Python 3.11
Searching for Python versions matching: Python 3.12
Installed 3 versions in 3.42s
+ cpython-3.10.14-macos-aarch64-none
+ cpython-3.11.9-macos-aarch64-none
+ cpython-3.12.4-macos-aarch64-none
```

--------------------------------

### Start Agent in Development Mode

Source: https://github.com/xpressai/xaibo/tree/main/examples/livekit_example

Starts the agent in development mode. The agent connects to your LiveKit project and is ready to join voice conversations in LiveKit rooms.

```shell
uv run python agent.py dev
```

--------------------------------

### Install Xaibo with Dependencies

Source: https://context7_llms

Provides commands to install the Xaibo package with specific dependency groups for web server, OpenAI, and Anthropic functionalities. Also shows how to perform a development installation.

```bash
pip install xaibo[webserver,openai,anthropic]
```

```bash
pip install -e .[webserver,openai,anthropic]
```

--------------------------------

### Installation Command

Source: https://context7_llms

The command to install the Xaibo library with support for LiveKit integration.

```bash
uv add xaibo[livekit]
```

--------------------------------

### Install Dependencies

Source: https://github.com/xpressai/xaibo/tree/main/examples/livekit_example

Command to synchronize dependencies for the agent. This is a crucial step after setting up API keys to ensure the agent has all necessary components.

```shell
uv sync
```

--------------------------------

### Install Xaibo Web Server Dependencies

Source: https://context7_llms

Installs the necessary Python packages for the Xaibo web server, including MCP adapter and JSON-RPC 2.0 support. This is the initial setup step before deployment.

```bash
pip install xaibo[webserver]
```

--------------------------------

### Start Xaibo Server

Source: https://context7_llms

Demonstrates how to start the Xaibo web server, specifying adapters. Command-line arguments can override environment variables for adapter configurations like API keys.

```bash
python -m xaibo.server.web \
  --adapter xaibo.server.adapters.OpenAiApiAdapter \
  --adapter xaibo.server.adapters.McpApiAdapter
```

```bash
python -m xaibo.server.web \
  --adapter xaibo.server.adapters.OpenAiApiAdapter \
  --openai-api-key "different-key"  # Overrides CUSTOM_OPENAI_API_KEY
```

--------------------------------

### API Usage: Retrieve Response

Source: https://context7_llms

Example of retrieving a specific response using its unique ID via a GET request to the /openai/responses/{response_id} endpoint.

```bash
curl http://localhost:8000/openai/responses/resp_abc123
```

--------------------------------

### Vite Development Server Output

Source: https://context7_llms

Example output from the Vite development server when starting the Xaibo UI, indicating the server is ready and providing access URLs.

```text
VITE v6.2.1  ready in 4584 ms

➜  Local:   http://localhost:5173/
➜  Network: use --host to expose
➜  press h + enter to show help
```

--------------------------------

### ConfigOverrides and ExchangeConfig Example

Source: https://context7_llms

Demonstrates how to use ConfigOverrides to inject pre-instantiated objects like a mock LLM and configure exchange protocols for testing or specific setups.

```python
from xaibo.core.config import ConfigOverrides, ExchangeConfig

# Override with mock LLM for testing
overrides = ConfigOverrides(
    instances={
        "llm": MockLLM(responses=["Test response"])
    },
    exchange=[
        ExchangeConfig(
            protocol="LLMProtocol",
            provider="llm"
        )
    ]
)

```

--------------------------------

### Agent Prompt Structure Examples

Source: https://context7_llms

Demonstrates consistent formatting for agent prompts, including thought, action, and observation phases, to guide agent behavior and reasoning.

```yaml
# Maintain consistent structure across prompts
thought_prompt: |
  ANALYZE: What does the user need?
  PLAN: What's your approach?

action_prompt: |
  DECIDE: Tool or final answer?
  EXECUTE: Take the chosen action.

observation_prompt: |
  REVIEW: What did you learn?
  NEXT: What's your next step?

```

```yaml
# Example tool call
action_prompt: |
  Choose your action:

  Example tool call:
  "I need weather data, so I'll call get_weather with location parameter"

  Example final answer:
  "FINAL_ANSWER: Based on my research, the answer is..."

```

--------------------------------

### Install Project Dependencies

Source: https://github.com/xpressai/xaibo/blob/main/examples/livekit_example/README

Installs the necessary dependencies for the project using the 'uv' package manager. This command synchronizes the project's environment.

```shell
uv sync
```

--------------------------------

### LiveKit Integration Setup

Source: https://context7_llms

Provides an example of setting up a LiveKit Agent with various components including VAD, STT, LLM, and TTS, using loaded Xaibo LLM.

```python
from livekit.agents import Agent
from livekit.plugins import openai, silero

# Assuming 'loader' is an instance of XaiboAgentLoader
# and has loaded an agent with ID 'my-agent'
# llm = loader.get_llm("my-agent")

# Placeholder for llm if not defined above
class MockXaiboLLM:
    def __call__(self, *args, **kwargs):
        return "Mock LLM response"

llm = MockXaiboLLM()

assistant = Agent(
    instructions="",
    vad=silero.VAD.load(),
    stt=openai.STT(),
    llm=llm,
    tts=openai.TTS(),
)
```

--------------------------------

### Start LiveKit Agent (Shell)

Source: https://github.com/xpressai/xaibo/blob/main/examples/livekit_example/README

This command initiates the LiveKit agent using the 'uv' tool. The agent is responsible for handling voice conversations and is integrated with the Xaibo dev server, providing a web interface for configuration inspection and behavior monitoring.

```shell
uv run python agent.py dev
```

--------------------------------

### Working with Xaibo Documentation Locally

Source: https://context7_llms

Instructions for running the local documentation server using MkDocs. This allows contributors to preview documentation changes before committing them.

```bash
# In the Xaibo base directory
uv run mkdocs serve
```

--------------------------------

### Initialize a New Xaibo Project

Source: https://context7_llms

Creates a new Xaibo project directory using the `uvx` command, preparing a workspace for development and testing.

```bash
uvx xaibo init my_test_project
```

--------------------------------

### Example Configuration for TextBasedToolCallAdapter

Source: https://context7_llms

Illustrates how to configure the TextBasedToolCallAdapter with a base LLM provider. This setup allows an LLM without native function calling to interact with tools via text-based prompts.

```yaml
modules:
  - module: xaibo.primitives.modules.llm.OpenAIProvider
    id: base-llm
    config:
      model: "gpt-4.1-nano"

  - module: xaibo.primitives.modules.tools.TextBasedToolCallAdapter
    id: text-based-llm

exchange:
  - module: text-based-llm
    protocol: LLMProtocol
    provider: base-llm

```

--------------------------------

### Complete LiveKit Voice Assistant Example

Source: https://context7_llms

A consolidated Python script demonstrating the full integration of Xaibo agents with LiveKit for a voice assistant, including setup, agent loading, and execution.

```python
import logging
from dotenv import load_dotenv

from livekit import rtc
from livekit.agents import (
    AutoSubscribe,
    JobContext,
    WorkerOptions,
    cli,
    Agent,
    AgentSession
)
from livekit.plugins import openai, silero

from xaibo.integrations.livekit import XaiboAgentLoader

# Load environment variables
load_dotenv(dotenv_path=".env")

# Configure logging
logger = logging.getLogger("xaibo-voice-assistant")
logger.setLevel(logging.INFO)

# Load Xaibo agents
loader = XaiboAgentLoader()
loader.load_agents_from_directory("./agents")
loader.enable_debug_logging("./debug")

# Get LLM from your agent
llm = loader.get_llm("example")

# Create voice assistant
assistant = Agent(
    instructions="",
    vad=silero.VAD.load(),
    stt=openai.STT(),
    llm=llm,
    tts=openai.TTS(),
)

async def entrypoint(ctx: JobContext):
    logger.info(f"Connecting to room {ctx.room.name}")
    await ctx.connect(auto_subscribe=AutoSubscribe.AUDIO_ONLY)

    session = AgentSession()
    await session.start(
        agent=assistant,
        room=ctx.room,
    )

    logger.info("Voice assistant started")

if __name__ == "__main__":
    cli.run_app(
        WorkerOptions(
            entrypoint_fnc=entrypoint,
        )
    )
```

--------------------------------

### cURL Example: MCP Initialization and Operations (With Auth)

Source: https://context7_llms

Provides cURL examples for initializing a connection, listing tools, and calling an agent with API key authentication. This demonstrates secure interaction with the MCP endpoint.

```bash
# Initialize connection
curl -X POST http://localhost:8000/mcp/ \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2024-11-05",
      "clientInfo": {"name": "test-client", "version": "1.0.0"}
    }
  }'

# List available tools
curl -X POST http://localhost:8000/mcp/ \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/list",
    "params": {}
  }'

# Call an agent
curl -X POST http://localhost:8000/mcp/ \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your-api-key" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "my-agent",
      "arguments": {"message": "Hello!"}
    }
  }'
```

--------------------------------

### BedrockLLM Configuration and Usage

Source: https://context7_llms

Details the configuration parameters for BedrockLLM, enabling integration with AWS Bedrock models. Includes setup examples with AWS credentials and regional deployment, highlighting multi-provider support and streaming capabilities.

```APIDOC
BedrockLLM Configuration:

Parameters:
  model (str): Bedrock model ID. Default: "anthropic.claude-v2".
  region_name (str): AWS region. Default: "us-east-1".
  aws_access_key_id (str): AWS access key (optional).
  aws_secret_access_key (str): AWS secret key (optional).
  timeout (float): Request timeout in seconds. Default: 60.0.
  temperature (float): Default sampling temperature. Default: None.
  max_tokens (int): Default maximum tokens to generate. Default: None.

Example Configuration:

modules:
  - module: xaibo.primitives.modules.llm.BedrockLLM
    id: bedrock-llm
    config:
      model: anthropic.claude-v2
      region_name: us-west-2
      temperature: 0.7
      max_tokens: 4096

Features:
  - Multi-Provider: Access to multiple model providers through Bedrock Converse API.
  - AWS Integration: Native AWS authentication and billing.
  - Streaming: Real-time response streaming.
  - Regional Deployment: Deploy in multiple AWS regions.
```

--------------------------------

### Troubleshoot Server Startup Errors

Source: https://context7_llms

Provides commands to test server startup independently and check for required dependencies. Reviewing server logs is also recommended for detailed error analysis.

```bash
# Test server startup
python -m mcp_server_filesystem --root . --verbose

# Check dependencies
pip list | grep mcp
```

--------------------------------

### Create Custom Python Tools

Source: https://context7_llms

Defines custom Python functions decorated with `@tool` to be used by Xaibo agents. Includes examples for getting current time, calculating sums, and formatting text with different styles.

```python
# tools/my_tools.py
from datetime import datetime, timezone
from xaibo.primitives.modules.tools.python_tool_provider import tool

@tool
def current_time():
    """Gets the current time in UTC"""
    return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")

@tool
def calculate_sum(numbers: list[float]) -> float:
    """Calculates the sum of a list of numbers"""
    return sum(numbers)

@tool
def format_text(text: str, style: str = "uppercase") -> str:
    """Formats text according to the specified style

    Args:
        text: The text to format
        style: Format style - 'uppercase', 'lowercase', or 'title'
    """
    if style == "uppercase":
        return text.upper()
    elif style == "lowercase":
        return text.lower()
    elif style == "title":
        return text.title()
    else:
        return text

```

--------------------------------

### Start Xaibo Server with OpenAI Adapter

Source: https://context7_llms

Initiates the Xaibo web server using the OpenAI API adapter. This command is used to launch the server with specific adapter configurations.

```bash
python -m xaibo.server.web --adapter xaibo.server.adapters.OpenAiApiAdapter
```

--------------------------------

### Python Weather Tool Examples

Source: https://context7_llms

Demonstrates how to define weather-related tools using the `@tool` decorator in Python. Includes functions for getting current weather and forecasts, with type annotations and docstrings for parameter and return value descriptions.

```Python
from xaibo.primitives.modules.tools.python_tool_provider import tool
import requests

@tool
def get_current_weather(city: str, units: str = "celsius") -> dict:
    """Get current weather for a city

    Args:
        city: Name of the city to get weather for
        units: Temperature units (celsius, fahrenheit, kelvin)

    Returns:
        Current weather information
    """
    # API call implementation
    response = requests.get(f"https://api.weather.com/v1/current", 
                          params={"city": city, "units": units})
    return response.json()

@tool
def get_weather_forecast(city: str, days: int = 5) -> list:
    """Get weather forecast for multiple days

    Args:
        city: Name of the city
        days: Number of days to forecast (1-10)

    Returns:
        List of daily weather forecasts
    """
    if not 1 <= days <= 10:
        raise ValueError("Days must be between 1 and 10")

    # Implementation here
    return [{"date": f"2024-01-{i+1}", "temp": 20+i} for i in range(days)]

```

--------------------------------

### GoogleLLM Configuration and Usage

Source: https://context7_llms

Details the configuration parameters for GoogleLLM, supporting both AI Studio (API key) and Vertex AI modes. Includes setup examples for different authentication methods and highlights features like multimodal support and function calling.

```APIDOC
GoogleLLM Configuration:

Parameters:
  model (str): Google model name. Default: "gemini-2.0-flash-001".
  api_key (str): Google API key (required for AI Studio mode). Does not check environment variables.
  vertexai (bool): Use Vertex AI instead of AI Studio. If true, uses service account authentication. Default: False.
  project (str): GCP project ID (required for Vertex AI mode).
  location (str): Vertex AI location. Default: "us-central1".
  temperature (float): Default sampling temperature. Default: None.
  max_tokens (int): Default maximum tokens to generate (mapped to `max_output_tokens` internally). Default: None.

Note: The `config` parameter is required for initialization. Either `api_key` (for AI Studio) or `vertexai=true` with `project` (for Vertex AI) must be provided.

Example Configurations:

# AI Studio (API key)
modules:
  - module: xaibo.primitives.modules.llm.GoogleLLM
    id: gemini-llm
    config:
      model: gemini-1.5-pro
      api_key: AIza...
      temperature: 0.7

# Vertex AI (service account)
modules:
  - module: xaibo.primitives.modules.llm.GoogleLLM
    id: gemini-vertex
    config:
      model: gemini-1.5-pro
      vertexai: true
      project: my-gcp-project
      location: us-central1

Features:
  - Multimodal: Native support for text, images, audio, and video.
  - Function Calling: Google function calling with parameter mapping to FunctionDeclaration format.
  - Image Format Detection: Automatic MIME type detection for images based on file extensions (.png, .gif, .webp, defaults to .jpeg).
  - Streaming: Real-time response streaming.
  - Safety Settings: Configurable content safety filters.

Implementation Details:
  - Image Format Detection: The `_convert_image` method handles data URIs and file URLs, detecting format from extension or defaulting to image/jpeg.
  - Vertex AI vs AI Studio: Automatically configures client based on `vertexai` parameter.
  - System Message Handling: System messages are passed as the `system_instruction` parameter to the Google API.
```

--------------------------------

### Use Multiple MCP Servers in an Agent

Source: https://context7_llms

An example YAML configuration for an agent designed to use multiple MCP servers simultaneously. It demonstrates integrating filesystem, git, web search (SSE), and database (WebSocket) servers within a single agent setup.

```yaml
# agents/multi_mcp_agent.yml
id: multi-mcp-agent
modules:
  - module: xaibo.primitives.modules.llm.OpenAILLM
    id: llm
    config:
      model: gpt-4
  - id: mcp-tools
    module: xaibo.primitives.modules.tools.MCPToolProvider
    config:
      timeout: 30.0
      servers:
        # Local filesystem access
        - name: fs
          transport: stdio
          command: ["python", "-m", "mcp_server_filesystem"]
          args: ["--root", "."]

        # Git repository management
        - name: git
          transport: stdio
          command: ["npx", "@modelcontextprotocol/server-git"]
          args: ["--repository", "."]

        # Web search capabilities
        - name: search
          transport: sse
          url: "https://search-api.example.com/mcp"
          headers:
            Authorization: "Bearer your-search-api-key"

        # Database operations
        - name: db
          transport: websocket
          url: "ws://localhost:8080/mcp"
          headers:
            X-Database-Key: "your-db-key"
  - module: xaibo.primitives.modules.orchestrator.SimpleToolOrchestrator
    id: orchestrator
    config:
      system_prompt: |
        You are a development assistant with access to:
        - Filesystem operations (fs.* tools)
        - Git repository management (git.* tools) 
        - Web search capabilities (search.* tools)
        - Database operations (db.* tools)

        Use these tools to help with development tasks.

```

--------------------------------

### Environment Initialization Script

Source: https://github.com/xpressai/xaibo/blob/main/examples/livekit_example/README

Loads a script responsible for initializing the client-side environment, potentially setting up global variables or configurations. This script is deferred.

```javascript
https://github.githubassets.com/assets/environment-17084f3f370f.js
```

--------------------------------

### JavaScript Worker Threads Example

Source: https://nodejs.org/

Demonstrates the basic setup for using Node.js worker threads. It shows how to import necessary modules, define main thread logic, and create a new worker. This snippet is intended for understanding the fundamental structure of worker thread communication.

```JavaScript
// threads.mjs
import { Worker, isMainThread } from "node:worker_threads";

if (isMainThread) {
  const data = "some data";
  const worker = new Worker("./threads.mjs", {
    workerData: data
  });

  worker.on("message", (msg) => {
    console.log(`Message from worker: ${msg}`);
  });

  worker.on("error", (err) => {
    console.error("Worker error:", err);
  });

  worker.on("exit", (code) => {
    if (code !== 0)
      console.error(`Worker stopped with exit code ${code}`);
  });

  // Send message to worker
  worker.postMessage("Hello from main thread!");
} else {
  // This code runs in the worker thread
  const { workerData, parentPort } = require("node:worker_threads");

  console.log("Worker thread started.");
  console.log("Worker data:", workerData);

  // Send message back to main thread
  parentPort.postMessage("Hello from worker thread!");
}

```

--------------------------------

### ExchangeConfig Examples

Source: https://context7_llms

Examples demonstrating dependency injection configurations for Xaibo agents, showing how to connect modules via protocols and specify providers, including special module IDs for entry and response handling.

```yaml
exchange:
  # Connect orchestrator to LLM
  - module: orchestrator
    protocol: LLMProtocol
    provider: llm

  # Set entry point for text messages
  - module: __entry__
    protocol: TextMessageHandlerProtocol
    provider: orchestrator

  # Multiple providers for a single protocol
  - module: tool_collector
    protocol: ToolProviderProtocol
    provider: [python-tools, mcp-tools]

```

--------------------------------

### Install uv on macOS/Linux

Source: https://docs.astral.sh/uv/

Installs uv using a curl script on macOS and Linux systems. This is the recommended standalone installation method for these platforms.

```Shell
curl -LsSf https://astral.sh/uv/install.sh | sh
```