### Docker Setup and Run Commands

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docker/test-instance/QUICK_START.md

These bash commands guide you through setting up, building, running, and testing the Agentic-Flow Docker instance. They include copying environment files, starting services in detached mode, and executing CLI commands within the container.

```bash
# 1. Setup
cd agentic-flow/docker/test-instance
cp .env.example .env
# Edit .env and add at least one API key (optional - works without keys too!)

# 2. Build and run
docker-compose up -d

# 3. Test
docker exec agentic-flow-test node /app/dist/cli-proxy.js --help
docker exec agentic-flow-test node /app/dist/cli-proxy.js --list

# 4. Interactive mode
docker exec -it agentic-flow-test /bin/bash
```

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

### Agentic-Flow Docker Development Setup

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docker/test-instance/QUICK_START.md

Instructions for setting up Agentic-Flow for development purposes using Docker. This involves configuring the Gemini free tier and starting the Docker Compose services.

```bash
# Use Gemini free tier
export GOOGLE_GEMINI_API_KEY=your-key
docker-compose up -d
```

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

### Install Claude Flow with MCP

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/MCP-QUICKSTART.md

Installs the Claude Flow tool using the MCP command-line interface. This is the first step to getting started with MCP tools.

```bash
claude mcp add claude-flow
npx claude-flow@alpha mcp start
```

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

### Run Quickstart Example

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentdb/examples/README.md

Executes the `quickstart.js` example file using Node.js. This example demonstrates basic AgentDB database initialization and version checking.

```bash
node examples/quickstart.js
```

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

### Run Example Configurations (Bash)

Source: https://github.com/ruvnet/agentic-flow/blob/main/examples/optimal-deployment/README.md

Executes example configurations for budget, balanced, and premium settings using npm scripts. These commands are used to test different deployment strategies. Dependencies: npm installed project.

```bash
npm run example:budget
npm run example:balanced
npm run example:premium
```

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

### Benchmark Documentation Creation

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentic-jujutsu/docs/getting-started/BENCHMARK_QUICK_START.md

Focuses on creating comprehensive benchmark documentation, including a getting started guide, usage instructions, prompt library, report interpretation guide, FAQ, and contributing guidelines. The documentation aims to be clear, concise, and provide examples for both AI agents and human developers.

```Markdown
GETTING_STARTED.md
USAGE_GUIDE.md
PROMPT_LIBRARY.md
INTERPRETATION_GUIDE.md
FAQ.md
CONTRIBUTING.md
```

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

### MCP Command: Add AgentDB

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/MCP-AUTHENTICATION.md

Adds the AgentDB service to the MCP. This command installs and starts the AgentDB service for MCP integration.

```bash
claude mcp add agentdb npx agentdb mcp
```

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

### Quick Setup for MCP Tools CLI

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentic-jujutsu/README.md

Steps to set up and start using MCP tools from the command line. This involves starting the MCP server, listing available tools, and making a tool call.

```bash
npx agentic-jujutsu mcp-server
npx agentic-jujutsu mcp-tools
npx agentic-jujutsu mcp-call jj_status
```

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

### MCP Command: Add Flow Nexus

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/MCP-AUTHENTICATION.md

Adds the Flow Nexus service to the MCP. This command installs the latest version of Flow Nexus and starts its MCP integration.

```bash
claude mcp add flow-nexus npx flow-nexus@latest mcp start
```

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

### Setup and Run Benchmark Script

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/releases/GITHUB-ISSUE-REASONINGBANK-BENCHMARK.md

These bash commands outline the necessary steps to set up the environment, install dependencies, and execute the benchmarking suite. It covers setting API keys, navigating directories, and running the benchmark script with different configurations.

```bash
# Set API key
export ANTHROPIC_API_KEY="sk-ant-..."

# Navigate to benchmark directory
cd /workspaces/agentic-flow/bench

# Ensure dependencies installed
cd ..
npm install
npm run build
cd bench
```

```bash
# Run all benchmarks (3 iterations, ~25-30 minutes)
./run-benchmark.sh

# Quick test (1 iteration, ~2-3 minutes)
./run-benchmark.sh quick 1

# Specific scenario
./run-benchmark.sh coding-tasks 3

# View results
cat reports/benchmark-*.md | less
```

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

### AgentDB Quickstart Example (JavaScript)

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentdb/docs/GITHUB_ISSUES.md

This JavaScript example provides a working 'quickstart' for AgentDB, demonstrating its programmatic API usage. It shows how to initialize the database with auto-setup, store an episode with reflection data, and retrieve similar episodes based on a query.

```javascript
// examples/quickstart.js
import { AgentDB } from 'agentdb';

async function main() {
  // Initialize database with auto-setup
  const db = await AgentDB.create({
    path: './agent-memory.db',
    dimensions: 384,
    backend: 'ruvector'
  });

  // Store episode
  await db.reflexion.store({
    sessionId: 'session-1',
    task: 'Implement authentication',
    reward: 0.95,
    success: true,
    critique: 'Used JWT tokens effectively'
  });

  // Search similar episodes
  const similar = await db.reflexion.retrieve('authentication', 5);
  console.log('Similar episodes:', similar);
}

main().catch(console.error);
```

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

### MCP Command: Add Claude Flow

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/MCP-AUTHENTICATION.md

Adds the Claude Flow service to the MCP. This command installs and starts the Claude Flow service, enabling its use with MCP.

```bash
claude mcp add claude-flow npx claude-flow@alpha mcp start
```

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

### Setup and Run LiteLLM Proxy

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/router/ROUTER_USER_GUIDE.md

Steps to install LiteLLM with proxy support, create a configuration file with model mappings and API keys, and start the LiteLLM proxy server.

```bash
# Install LiteLLM
pip install litellm[proxy]

# Create config
cat > litellm_config.yaml << EOF
model_list:
  - model_name: gpt-4
    litellm_params:
      model: gpt-4
      api_key: ${OPENAI_API_KEY}
  - model_name: claude-3-opus
    litellm_params:
      model: claude-3-opus-20240229
      api_key: ${ANTHROPIC_API_KEY}
  - model_name: gemini-pro
    litellm_params:
      model: gemini/gemini-pro
      api_key: ${GOOGLE_API_KEY}
EOF

# Start proxy
litellm --config litellm_config.yaml --port 8000
```

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

### Agentic Jujutsu CLI: Getting Started Commands (Bash)

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentic-jujutsu/README.md

Lists essential npx CLI commands for getting started with agentic-jujutsu, including commands for help, version, package information, and examples.

```bash
# Show all available commands
npx agentic-jujutsu help

# Show version and system info
npx agentic-jujutsu version

# Show package information and features
npx agentic-jujutsu info

# Show usage examples
npx agentic-jujutsu examples
```

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

### Verify MCP Server Installation and Status

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/MCP-AUTHENTICATION.md

Lists all currently installed MCP servers and displays their status. This command is useful for confirming that the servers were installed correctly and are running.

```bash
# List all installed MCP servers
claude mcp list
```

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

### Best Practice: Start with Validated Scenarios

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentdb/simulation/docs/guides/WIZARD-GUIDE.md

This bash example demonstrates the recommended approach of first running validated scenarios before building custom configurations. It shows the command flow for selecting validated scenarios and then building custom simulations.

```bash
# Good: Learn from validated scenarios first
agentdb simulate --wizard → "Run validated scenario"

# Then: Build custom after understanding components
agentdb simulate --wizard → "Build custom simulation"
```

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

### Install agentic-flow globally

Source: https://github.com/ruvnet/agentic-flow/blob/main/examples/climate-prediction/docs/GETTING_STARTED.md

Installs the `agentic-flow` package globally using npm. This command ensures that `agentic-flow` is accessible from any directory. It then verifies the installation by checking the version.

```bash
# Install globally
npm install -g agentic-flow@latest

# Verify installation
npx agentic-flow --version
```

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

### Application Configuration Example (YAML)

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/specs/EXECUTIVE-SUMMARY.md

Provides a complete application configuration example, demonstrating progressive delivery setup, infrastructure requirements, policy enforcement, and observability configuration. This file is crucial for understanding how to deploy and manage the application.

```yaml
apiVersion: example.com/v1alpha1
kind: AppConfig
metadata:
  name: my-app
spec:
  delivery:
    progressive: canary
    steps:
      - name: early-adopters
        percentage: 10
      - name: mainstream
        percentage: 90
  infrastructure:
    requirements:
      cpu: 1
      memory: 2Gi
  policy:
    enforcement: strict
  observability:
    metrics: prometheus
    logs: fluentd
```

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

### Reproducibility Setup Command (Bash)

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentic-jujutsu/docs/benchmarks/BENCHMARKING_GUIDE.md

Example command to set up a benchmarking environment for good reproducibility. It utilizes npm to run benchmarks with specific configurations like iterations, warmup runs, Docker, and sequential parallel execution for fairness.

```bash
# Good reproducibility setup
npm run bench:run \
  --iterations 20 \
  --warmup 5 \
  --docker \
  --parallel 1  # Sequential for fairness

# Results should vary < 5% across runs
```

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

### Install Jujutsu CLI

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentic-jujutsu/docs/getting-started/BENCHMARK_QUICK_START.md

Installs the Jujutsu command-line interface from its Git repository using Cargo. This is a prerequisite for using Jujutsu.

```bash
# Install jujutsu
cargo install --git https://github.com/martinvonz/jj.git jj-cli

# Verify installation
jj --version
```

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

### Install AgentDB CLI Globally

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentdb/simulation/docs/guides/QUICK-START.md

Installs the AgentDB command-line interface globally on your system using npm. This is the recommended method for most users. After installation, you can verify it by checking the version.

```bash
npm install -g agentdb
agentdb --version
```

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

### Full Workflow Example: Learning from Authentication Implementation

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/testing/AGENTDB_TESTING.md

An example bash script demonstrating a full workflow for learning from authentication implementation. It sets up a test database, stores successful and failed authentication attempts using the reflexion store command, simulating a learning process.

```bash
#!/bin/bash

# Set up test database
export AGENTDB_PATH=./auth-learning.db

# 1. Store successful attempts
node dist/agentdb/cli/agentdb-cli.js reflexion store \
  "session-auth-1" "oauth2_implementation" 0.95 true \
  "Used industry-standard OAuth2 flow" \
  "Implement secure login" "Working OAuth2 system" 1500 6000

node dist/agentdb/cli/agentdb-cli.js reflexion store \
  "session-auth-2" "jwt_tokens" 0.90 true \
  "JWT with proper expiration and refresh tokens" \
  "Token management" "Secure JWT system" 1200 5500

# 2. Store failed attempts
node dist/agentdb/cli/agentdb-cli.js reflexion store \
  "session-auth-3" "session_storage" 0.35 false \
  "Insecure session storage in localStorage" \
  "Session management" "Security vulnerability" 800 3000

```

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

### Install and Verify AgentDB MCP Server

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/MCP-AUTHENTICATION.md

Installs the AgentDB MCP server using the 'claude mcp add' command and verifies its installation by listing available MCP services.

```bash
# Install AgentDB MCP server
claude mcp add agentdb npx agentdb mcp

# Verify installation
claude mcp list
```

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

### AgentDB Quick Start

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentic-jujutsu/README.md

Provides a basic JavaScript example of initializing JJWrapper and executing common repository operations like status, new commit, and rebase. It also shows how to retrieve and display operation statistics.

```javascript
const { JjWrapper } = require('agentic-jujutsu');

const jj = new JjWrapper();

// Execute operations (automatically tracked)
await jj.status();
await jj.newCommit('Add feature');
await jj.rebase('main');

// View statistics
const stats = JSON.parse(jj.getStats());
console.log(`Operations: ${stats.total_operations}`);
console.log(`Success Rate: ${(stats.success_rate * 100).toFixed(1)}%`);
console.log(`Avg Duration: ${stats.avg_duration_ms.toFixed(2)}ms`);
```

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

### Clone and Setup Climate Prediction Project

Source: https://github.com/ruvnet/agentic-flow/blob/main/examples/climate-prediction/docs/DEVELOPMENT.md

Guides through cloning the Climate Prediction repository, installing Rust dependencies using `cargo fetch`, installing development tools like `cargo-watch`, and setting up pre-commit hooks.

```bash
# Clone repository
git clone https://github.com/yourusername/climate-prediction.git
cd climate-prediction

# Install Rust dependencies
cargo fetch

# Install development tools
cargo install cargo-watch cargo-tarpaulin cargo-audit cargo-outdated

# Install pre-commit hooks
./scripts/install-hooks.sh

# Setup development database (optional)
./scripts/setup-dev-db.sh
```

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

### AgentDB Initialization CLI Examples

Source: https://github.com/ruvnet/agentic-flow/blob/main/plans/agentdb-v2/ARCHITECTURE.md

Examples demonstrating how to use the `agentdb init` CLI command with different configurations. This includes auto-detection, forcing specific backends, enabling optional features, and using default or custom paths.

```bash
# Auto-detect (recommended)
agentdb init

# Force specific backend
agentdb init --backend=ruvector
agentdb init --backend=hnswlib

# With options
agentdb init --backend=ruvector --enable-gnn --enable-compression

# Show detection info
agentdb init --dry-run

```

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

### Install Rust with rustup

Source: https://github.com/ruvnet/agentic-flow/blob/main/examples/climate-prediction/docs/GETTING_STARTED.md

Installs the Rust programming language and its package manager, Cargo, using the official rustup installer. It then sources the environment variables and verifies the installation by checking the Rust and Cargo versions.

```bash
# Install Rust using rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Source environment
source $HOME/.cargo/env

# Verify installation
rustc --version
cargo --version
```

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

### Install Agentic Flow using npm

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/guides/QUICK-START-v1.7.1.md

This snippet shows how to install the agentic-flow package using npm. You can install a specific version (v1.7.1) or the latest stable release.

```bash
npm install agentic-flow@1.7.1
# or
npm install agentic-flow@latest
```

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

### Update .env.example for Requesty (Bash)

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/plans/requesty/02-architecture.md

Shows how to update the .env.example file to include Requesty-specific configuration options. This helps users set up their environment correctly.

```bash
# Add to .env.example
# ============================================
# Requesty Configuration
# ============================================
REQUESTY_API_KEY=                               # Get from https://app.requesty.ai
REQUESTY_BASE_URL=https://router.requesty.ai/v1 # Optional: Custom base URL
USE_REQUESTY=false                              # Set to 'true' to force Requesty
```

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

### Run AgentDB Simulation with Interactive Wizard

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentdb/simulation/docs/guides/QUICK-START.md

Launches the AgentDB simulation setup in an interactive wizard mode. The wizard guides the user through selecting scenarios, configuring parameters like the number of nodes and dimensions, and starting the simulation.

```bash
agentdb simulate --wizard
```

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

### Quickstart Programmatic Usage Example

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentdb/PUBLISH-ALPHA-2-SUMMARY.md

An example JavaScript file demonstrating how to use AgentDB programmatically. This is a new feature included in the package for user convenience.

```javascript
// examples/quickstart.js
// This is a placeholder for the actual code content.
// The file was added in this release to show programmatic usage.
console.log('AgentDB quickstart example running...');

```

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

### Installation and Build Commands

Source: https://github.com/ruvnet/agentic-flow/blob/main/src/README.md

These bash commands outline the steps required to set up and run the project. They include installing dependencies using npm, building the project, and starting the API server. Instructions are also provided for running the CLI tool with sample arguments.

```bash
# Install dependencies
npm install

# Build
npm run build

# Run API server
npm start

# Run CLI
npm run cli -- analyze "condition" -s "symptom1" "symptom2"
```

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

### Install agentic-flow with npm

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/guides/QUIC-SWARM-QUICKSTART.md

Installs the agentic-flow library using npm. This is the first step to begin using the swarm coordination features.

```bash
npm install agentic-flow
```

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

### Dockerfile for agentic-jujutsu Setup

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentic-jujutsu/docs/INSTALLATION.md

A Dockerfile to set up an environment with Rust, Cargo, 'jj', and 'agentic-jujutsu'. It installs Node.js, Rust, Cargo, 'jj' via Cargo, and 'agentic-jujutsu' via npm, finally verifying the installations.

```dockerfile
FROM node:20

# Install Rust and Cargo
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
ENV PATH="/root/.cargo/bin:${PATH}"

# Install jj
RUN cargo install --git https://github.com/martinvonz/jj jj-cli

# Install agentic-jujutsu
RUN npm install -g agentic-jujutsu

# Verify
RUN jj --version && agentic-jujutsu version
```

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

### Setup Agentic Flow Environment and Configuration

Source: https://github.com/ruvnet/agentic-flow/blob/main/examples/optimal-deployment/README.md

Installs the agentic-flow package, sets up necessary environment variables (like API keys and budget), and loads a balanced configuration file for deployment.

```bash
# Install dependencies
npm install agentic-flow

# Set up .env
cat > .env << EOF
OPENROUTER_API_KEY=sk-or-your-key-here
DEPLOYMENT_CONFIG=balanced
MONTHLY_BUDGET=200
ENABLE_COST_TRACKING=true
EOF
```

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

### Install and Verify Claude Flow MCP Server

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/MCP-AUTHENTICATION.md

Installs the Claude Flow MCP server using the 'claude mcp add' command and verifies its installation by listing available MCP services.

```bash
# Install Claude Flow MCP server
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Verify installation
claude mcp list
```

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

### Prerequisites and Benchmark Setup (Bash)

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/releases/GITHUB-ISSUE-v1.5.0.md

Sets up the environment for running the agentic-flow benchmarks. This includes exporting an API key, installing dependencies, building the project, and navigating to the benchmark directory. These steps are crucial before executing any benchmark scripts.

```bash
export ANTHROPIC_API_KEY="sk-ant-..."
cd /workspaces/agentic-flow
npm install && npm run build
cd bench
```

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

### Install Node.js and npm on Ubuntu/macOS

Source: https://github.com/ruvnet/agentic-flow/blob/main/examples/climate-prediction/docs/GETTING_STARTED.md

Installs Node.js and npm. For Ubuntu/Debian systems, it uses NodeSource repositories. For macOS, it utilizes Homebrew. The installation is verified by checking the versions of Node.js and npm.

```bash
**Ubuntu/Debian:**
```bash
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs
```

**macOS:**
```bash
brew install node
```

**Verify:**
```bash
node --version
npm --version
```
```

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

### AgentDB Initialization Command Examples (Bash)

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentdb/ALPHA-2.4-COMPLETE-REPORT.md

This snippet provides bash examples for initializing the agentdb using the CLI. It covers basic initialization with default settings, setting dimensions for production quality, and explicitly selecting models for different quality and language needs. It also demonstrates advanced configurations like presets, backend selection, in-memory mode, and quick prototyping.

```bash
# Default (fast prototyping)
agentdb init
# → Uses Xenova/all-MiniLM-L6-v2 (384-dim)

# Production quality
agentdb init --dimension 768
# → Uses Xenova/bge-base-en-v1.5 (768-dim)
```

```bash
# Best 384-dim quality
agentdb init --dimension 384 --model "Xenova/bge-small-en-v1.5"

# Production quality (768-dim)
agentdb init --dimension 768 --model "Xenova/bge-base-en-v1.5"

# All-around excellence
agentdb init --dimension 768 --model "Xenova/all-mpnet-base-v2"

# Multilingual (100+ languages)
agentdb init --dimension 768 --model "Xenova/e5-base-v2"
```

```bash
# Large dataset with production quality
agentdb init \
  --dimension 768 \
  --model "Xenova/bge-base-en-v1.5" \
  --preset large \
  --backend ruvector

# Testing and development
agentdb init --in-memory --dimension 384

# Quick prototyping
agentdb init --preset small
```

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

### Build and Install N-API Project

Source: https://github.com/ruvnet/agentic-flow/blob/main/packages/agentic-jujutsu/docs/guides/napi-guide.md

Provides the basic commands to install dependencies and build an N-API project. `npm install` installs Node.js dependencies, and `npm run build` triggers the native compilation process using `@napi-rs/cli`.

```bash
# Install Node.js dependencies
npm install

# Build the native N-API addon
npm run build
```

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

### Project Build and Run Commands

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/guides/IMPLEMENTATION_EXAMPLES.md

This section provides essential bash commands for managing the project. It covers installing dependencies with npm, running the development server, building for production, starting the production server, and executing the application with Docker Compose. It also includes commands for performing health checks and accessing metrics.

```bash
# Install dependencies
npm install

# Development
npm run dev

# Production
npm run build
npm start

# With Docker
docker compose up --build

# Health check
curl http://localhost:3000/health

# Metrics
curl http://localhost:3000/metrics
```

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

### Environment Variables Configuration (.env.example)

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/IMPLEMENTATION_EXAMPLES.md

Example environment file (.env.example) outlining required and optional variables for the application. Includes API keys, topic settings, logging levels, and monitoring ports.

```dotenv
# .env.example

# Required
ANTHROPIC_API_KEY=sk-ant-...

# Optional
TOPIC="migrate payments service"
DIFF="feat: add payments router and mandate checks"
DATASET="monthly tx volume, refunds, chargebacks"

# Logging
LOG_LEVEL=info

# Health Check
HEALTH_PORT=3000

# Metrics
METRICS_PORT=9090

# Retry Configuration
MAX_RETRIES=3
BACKOFF_MS=1000
MAX_BACKOFF_MS=30000

```

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

### Project Setup and Development Workflow (Bash)

Source: https://github.com/ruvnet/agentic-flow/blob/main/agentic-flow/docs/architecture/QUICK_WINS.md

Provides bash commands for setting up and running the project. Includes steps for updating agent configurations, installing dependencies (winston, express, @types/express), and starting the development server. Also shows how to test the health check endpoint using curl and monitor logs.

```bash
# 1. Update agent files
# Add allowedTools to each agent's options

# 2. Test
npm run dev
# Verify agents can now use tools

# 1. Install dependencies
npm install winston

# 1. Install express
npm install express @types/express

# 2. Add health endpoint
# 3. Test
curl http://localhost:3000/health

TOPIC="Claude Agent SDK best practices 2025" npm run dev

# Set invalid API key for one agent
ANTHROPIC_API_KEY=invalid npm run dev

npm run dev | grep -v "^$"

# Terminal 1
npm run dev

# Terminal 2
curl http://localhost:3000/health
tail -f agents.log
```

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

### List Installed MCP Servers

Source: https://github.com/ruvnet/agentic-flow/blob/main/docs/guides/MCP-QUICKSTART.md

Verifies the installation of MCP servers by listing all currently installed servers using the `claude mcp list` command. The output should include `claude-flow` if it was successfully added.

```bash
# List installed servers
claude mcp list
```

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

### Install Claude Flow alpha version

Source: https://github.com/ruvnet/agentic-flow/blob/main/examples/climate-prediction/docs/GETTING_STARTED.md

Installs the alpha version of the Claude Flow package globally using npm. This command is used to install pre-release versions for testing. The installation is verified by checking the specific alpha version.

```bash
# Install Claude Flow alpha version
npm install -g @ruv/claude-flow@alpha

# Verify installation
npx claude-flow@alpha --version
```