### Install and Start OpenCode Server

Source: https://pocketpaw.xyz/backends/opencode

This snippet shows how to install the OpenCode Go binary and start it in server mode. The server defaults to running on http://localhost:4096. Ensure you have Go installed to use these commands.

```bash
# Install the OpenCode Go binary
go install github.com/opencode-ai/opencode@latest
# Start in server mode
opencode --server
```

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

### Install and Configure OpenCode Backend

Source: https://pocketpaw.xyz/llms-full.txt

Instructions for installing the OpenCode Go binary, starting the server, and configuring the PocketPaw environment variables to connect to the external service.

```bash
# Install the OpenCode Go binary
go install github.com/opencode-ai/opencode@latest

# Start in server mode
opencode --server
```

```bash
export POCKETPAW_AGENT_BACKEND="opencode"
```

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

### Install and Setup Ollama for Local AI

Source: https://pocketpaw.xyz/llms-full.txt

Steps to install the Ollama runtime, pull open-source models, and configure PocketPaw to use local inference instead of cloud APIs.

```bash
# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh
ollama --version

# Pull models
ollama pull qwen2.5:7b

# Configure PocketPaw
export POCKETPAW_LLM_PROVIDER="ollama"
export POCKETPAW_OLLAMA_MODEL="qwen2.5:7b"
```

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

### Get Memory Settings API Endpoint Examples

Source: https://pocketpaw.xyz/api/get-memory-settings

Provides examples for making a GET request to the `/api/memory/settings` endpoint. This endpoint is used to retrieve memory settings, likely for an application. Examples are provided in cURL, JavaScript, Python, and Go.

```curl
curl -X GET "http://localhost:8000/api/memory/settings" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <token>"
```

```javascript
const response = await fetch("http://localhost:8000/api/memory/settings", {
  method: "GET",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();
console.log(data);
```

```python
import requests

response = requests.get(
    "http://localhost:8000/api/memory/settings",
    headers={'Content-Type':'application/json','Authorization':'Bearer <token>'},
)

print(response.json())
```

```go
package main

import (
    "fmt"
    "net/http"
    "io"
)

func main() {
    req, _ := http.NewRequest("GET", "http://localhost:8000/api/memory/settings", nil)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer <token>")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

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

### Setup PocketPaw with Mem0 Integration (Bash)

Source: https://pocketpaw.xyz/llms-full.txt

Provides bash commands to install PocketPaw and configure Mem0 for semantic long-term memory. Includes environment variables for LLM provider, model, embedder, and vector store.

```bash
# Install PocketPaw
curl -fsSL https://pocketpaw.xyz/install.sh | sh


# Or add the memory extra manually
pip install pocketpaw[memory]


# Configure Mem0
export POCKETPAW_MEM0_AUTO_LEARN=true
export POCKETPAW_MEM0_LLM_PROVIDER="ollama"
export POCKETPAW_MEM0_LLM_MODEL="llama3.2"
export POCKETPAW_MEM0_EMBEDDER_PROVIDER="ollama"
export POCKETPAW_MEM0_EMBEDDER_MODEL="nomic-embed-text"
export POCKETPAW_MEM0_VECTOR_STORE="qdrant"
```

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

### Shell Commands for PocketPaw Setup and Management

Source: https://pocketpaw.xyz/deployment/systemd

A collection of essential terminal commands for setting up and managing the PocketPaw service. This includes creating users, installing PocketPaw, configuring directories, enabling/disabling systemd services, and checking status and logs.

```bash
# Create dedicated users
sudo useradd -m -s /bin/bash pocketpaw

# Install PocketPaw
sudo -u pocketpaw pip install --user pocketpaw[recommended]

# Create config directory
sudo mkdir -p /etc/pocketpawsudo chown pocketpaw:pocketpaw /etc/pocketpaw

# Enable and start services
sudo systemctl daemon-reloadsudo systemctl enable pocketpawsudo systemctl start pocketpaw

# Start
sudo systemctl start pocketpaw

# Stop
sudo systemctl stop pocketpaw

# Restart
sudo systemctl restart pocketpaw

# Check status
sudo systemctl status pocketpaw

# View logs
sudo journalctl -u pocketpaw -f

# View recent logs
sudo journalctl -u pocketpaw --since "1 hour ago"
```

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

### List MCP Presets API Endpoint

Source: https://pocketpaw.xyz/api/get-mcp-presets

This section provides code examples for interacting with the GET /api/mcp/presets endpoint. It demonstrates how to fetch the list of MCP server presets and their installation status using different programming languages and tools.

```curl
curl -X GET "http://localhost:8000/api/mcp/presets" \
  -H "Authorization: Bearer <token>"
```

```javascript
const response = await fetch("http://localhost:8000/api/mcp/presets", {  headers: { "Authorization": "Bearer <token>" }}});
const data = await response.json();
console.log(data);
```

```python
import requests
response = requests.get(
    "http://localhost:8000/api/mcp/presets",
    headers={"Authorization": "Bearer <token>"})
print(response.json())
```

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

### Install PocketPaw with Matrix Support

Source: https://pocketpaw.xyz/llms-full.txt

Installation commands to set up PocketPaw, including the optional matrix-nio dependency.

```bash
curl -fsSL https://pocketpaw.xyz/install.sh | sh

pip install pocketpaw[matrix]
```

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

### Initialize PocketPaw Repository

Source: https://pocketpaw.xyz/llms-full.txt

Standard commands to clone the PocketPaw repository and prepare the environment configuration file.

```bash
# Clone the repo
git clone https://github.com/pocketpaw/pocketpaw.git
cd pocketpaw

# Copy the env template and fill in your keys
cp .env.example .env
```

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

### Get Self Audit Reports API Examples

Source: https://pocketpaw.xyz/api/get-self-audit-reports

Examples for making a GET request to the /api/self-audit/reports endpoint using cURL, JavaScript, Python, and Go. These examples demonstrate how to set the necessary headers, including Content-Type and Authorization.

```curl
curl -X GET "http://localhost:8000/api/self-audit/reports" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <token>"
```

```javascript
const response = await fetch("http://localhost:8000/api/self-audit/reports", {
  method: "GET",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();
console.log(data);
```

```python
import requests

response = requests.get(
    "http://localhost:8000/api/self-audit/reports",
    headers={'Content-Type':'application/json','Authorization':'Bearer <token>'},
)

print(response.json())
```

```go
package main

import (
    "fmt"
    "net/http"
    "io"
)

func main() {
    req, _ := http.NewRequest("GET", "http://localhost:8000/api/self-audit/reports", nil)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer <token>")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

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

### Get Remote Status API Request

Source: https://pocketpaw.xyz/api/get-tunnel-status

Examples for making a GET request to the /api/remote/status endpoint. This endpoint is likely used to check the status of a remote service. The examples demonstrate how to include necessary headers like Content-Type and Authorization.

```curl
curl -X GET "http://localhost:8000/api/remote/status" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <token>"
```

```javascript
const response = await fetch("http://localhost:8000/api/remote/status", {
  method: "GET",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();
console.log(data);
```

```python
import requests

response = requests.get(
    "http://localhost:8000/api/remote/status",
    headers={'Content-Type':'application/json','Authorization':'Bearer <token>'},
)

print(response.json())
```

```go
package main

import (
    "fmt"
    "net/http"
    "io"
)

func main() {
    req, _ := http.NewRequest("GET", "http://localhost:8000/api/remote/status", nil)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer <token>")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

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

### Start PocketPaw with Ollama using Docker Compose Profile

Source: https://pocketpaw.xyz/llms-full.txt

Starts PocketPaw along with the Ollama service using a specific Docker Compose profile. This allows for local LLM inference. It also shows how to configure the Ollama host and pull necessary models.

```bash
docker compose --profile ollama up -d
```

```bash
POCKETPAW_OLLAMA_HOST=http://ollama:11434
```

```bash
docker compose exec ollama ollama pull llama3.2
```

```bash
docker compose exec ollama ollama pull nomic-embed-text
```

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

### Install Discord Extra Manually (Python)

Source: https://pocketpaw.xyz/channels/discord

Installs the PocketPaw package with the Discord extra dependencies using pip. This method allows for more granular control over installation.

```python
pip install pocketpaw[discord]
```

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

### Copy Environment Example File

Source: https://pocketpaw.xyz/llms-full.txt

Copies the example environment file (`.env.example`) to a new file named `.env`. This `.env` file should then be edited to configure PocketPaw settings.

```bash
cp .env.example .env
```

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

### Install PocketPaw with Discord Extra (Shell)

Source: https://pocketpaw.xyz/channels/discord

Installs PocketPaw using a curl script, ensuring the Discord extra dependencies are included. This is an alternative installation method.

```shell
curl -fsSL https://pocketpaw.xyz/install.sh | sh
```

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

### Start PocketPaw Web Dashboard

Source: https://pocketpaw.xyz/llms-full.txt

These commands demonstrate how to start the PocketPaw web dashboard. The default command starts it in its default mode. You can also specify the host and port by setting environment variables before running the command.

```bash
# Default mode — starts the web dashboard
pocketpaw


# Specify host and port
export POCKETPAW_DASHBOARD_HOST="0.0.0.0"
export POCKETPAW_DASHBOARD_PORT=8000
pocketpaw
```

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

### Start PocketPaw with Channel Support

Source: https://pocketpaw.xyz/llms-full.txt

Commands to launch the PocketPaw service with specific channel flags enabled.

```bash
pocketpaw --teams
pocketpaw --telegram
```

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

### MCP Status API Request Examples

Source: https://pocketpaw.xyz/api/get-mcp-status

Examples of how to request the MCP status from the API using different programming languages. These examples demonstrate making a GET request to '/api/mcp/status' with necessary headers for authentication and content type.

```curl
curl -X GET "http://localhost:8000/api/mcp/status" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <token>"
```

```javascript
const response = await fetch("http://localhost:8000/api/mcp/status", {
  method: "GET",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer <token>"
  },
});

const data = await response.json();
console.log(data);
```

```python
import requests

response = requests.get(
    "http://localhost:8000/api/mcp/status",
    headers={'Content-Type':'application/json','Authorization':'Bearer <token>'},
)

print(response.json())
```

```go
package main

import (
    "fmt"
    "net/http"
    "io"
)

func main() {
    req, _ := http.NewRequest("GET", "http://localhost:8000/api/mcp/status", nil)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer <token>")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
```

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

### Start PocketPaw with Qdrant using Docker Compose Profile

Source: https://pocketpaw.xyz/llms-full.txt

Starts the PocketPaw service along with the Qdrant vector database using a Docker Compose profile. Qdrant is necessary for enabling Mem0 semantic memory functionality.

```bash
docker compose --profile qdrant up -d
```

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

### Install Ollama using curl

Source: https://pocketpaw.xyz/backends/ollama

This command downloads and executes the Ollama installation script from the official website. It's a straightforward way to get Ollama set up on your system. Ensure you have curl installed and execute this in your terminal.

```bash
curl -fsSL https://ollama.com/install.sh | sh
```

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

### MCP Tool Policy Examples (Bash)

Source: https://pocketpaw.xyz/llms-full.txt

These bash examples show how to configure MCP tool policies using environment variables. `POCKETPAW_TOOLS_ALLOW` permits all tools from a specific MCP server (e.g., `mcp:filesystem:*`), while `POCKETPAW_TOOLS_DENY` can block all MCP tools by targeting the `group:mcp` pattern.

```bash
# Allow all tools from a specific MCP server
export POCKETPAW_TOOLS_ALLOW="mcp:filesystem:*"


# Deny all MCP tools
export POCKETPAW_TOOLS_DENY="group:mcp"
```

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

### Start PocketPaw Discord Bot (Shell)

Source: https://pocketpaw.xyz/channels/discord

Starts the PocketPaw bot with Discord integration enabled. This command assumes the bot token environment variable is already set.

```shell
pocketpaw --discord
```

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

### Retrieve Audit Logs (API Request Example)

Source: https://pocketpaw.xyz/api/get-audit-logs

This example demonstrates how to retrieve audit logs from the PocketPaw API. It uses a GET request to the `/api/audit` endpoint with an 'Bearer' authentication token. The response contains timestamped security events with severity levels and structured metadata.

```shell
GET /api/audit Bearer
```

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

### Install PocketPaw Dependencies

Source: https://pocketpaw.xyz/llms-full.txt

Installation commands for the PocketPaw CLI and optional channel-specific SDKs.

```bash
curl -fsSL https://pocketpaw.xyz/install.sh | sh
pip install pocketpaw[teams]
```

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

### Start All PocketPaw Services

Source: https://pocketpaw.xyz/llms-full.txt

Starts PocketPaw along with both Ollama and Qdrant services using their respective Docker Compose profiles. This command ensures all dependencies for local LLM and semantic memory are running.

```bash
docker compose --profile ollama --profile qdrant up -d
```

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

### Channels API

Source: https://pocketpaw.xyz/api/post-mcp-preset-install

Endpoints for managing communication channels, including getting status, saving configurations, and toggling channels.

```APIDOC
## GET /api/get-channels-status

### Description
Retrieves the current status of all available channels.

### Method
GET

### Endpoint
/api/get-channels-status

### Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **channels** (object) - An object containing the status of each channel.

#### Response Example
```json
{
  "channels": {
    "channel_name_1": "active",
    "channel_name_2": "inactive"
  }
}
```
```

```APIDOC
## POST /api/post-channels-save

### Description
Saves the configuration for a specific channel.

### Method
POST

### Endpoint
/api/post-channels-save

### Parameters
#### Request Body
- **channel_name** (string) - Required - The name of the channel to configure.
- **config** (object) - Required - The configuration object for the channel.

### Request Example
```json
{
  "channel_name": "my_channel",
  "config": {
    "setting1": "value1",
    "setting2": 123
  }
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating the configuration was saved.

#### Response Example
```json
{
  "message": "Channel configuration saved successfully."
}
```
```

```APIDOC
## POST /api/post-channels-toggle

### Description
Toggles the status of a specific channel (e.g., enable/disable).

### Method
POST

### Endpoint
/api/post-channels-toggle

### Parameters
#### Request Body
- **channel_name** (string) - Required - The name of the channel to toggle.
- **enable** (boolean) - Required - Set to true to enable the channel, false to disable.

### Request Example
```json
{
  "channel_name": "my_channel",
  "enable": true
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating the channel status was updated.

#### Response Example
```json
{
  "message": "Channel status updated successfully."
}
```
```

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

### Start PocketPaw Dashboard

Source: https://pocketpaw.xyz/channels/web-dashboard

Commands to launch the PocketPaw web dashboard, including options to customize the host and port via environment variables.

```bash
# Default mode
pocketpaw

# Specify host and port
export POCKETPAW_DASHBOARD_HOST="0.0.0.0"
export POCKETPAW_DASHBOARD_PORT=8000
pocketpaw
```

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

### GET /api/mcp/presets

Source: https://pocketpaw.xyz/api/get-mcp-presets

Retrieves a list of all available MCP server presets. These presets are pre-configured server templates that can be installed with a single click from the dashboard.

```APIDOC
## GET /api/mcp/presets

### Description
Get all available MCP server presets with their installation status. Presets are pre-configured server templates that can be installed with a single click from the dashboard.

### Method
GET

### Endpoint
/api/mcp/presets

### Parameters
#### Query Parameters
None

#### Headers
- **Authorization** (string) - Required - Bearer token for authentication

### Request Example
```bash
curl -X GET "http://localhost:8000/api/mcp/presets" \
  -H "Authorization: Bearer <token>"
```

### Response
#### Success Response (200)
Returns an array of preset objects:
- **id** (string) - Unique preset identifier (e.g., `filesystem`, `github`)
- **name** (string) - Human-readable display name
- **description** (string) - Description of what the server provides
- **icon** (string) - Lucide icon name for the preset
- **category** (string) - Category grouping (e.g., `filesystem`, `developer`, `data`)
- **installed** (boolean) - Whether this preset is already configured
- **env_keys** (array) - List of environment variable names the preset requires
- **oauth** (boolean) - Whether this preset uses OAuth authentication

#### Response Example
```json
[
  {
    "id": "filesystem",
    "name": "Filesystem",
    "description": "Read, write, and manage files on the local filesystem",
    "icon": "lucide:folder",
    "category": "filesystem",
    "installed": true,
    "env_keys": [],
    "oauth": false
  },
  {
    "id": "github",
    "name": "GitHub",
    "description": "Manage repos, issues, PRs, and files (OAuth)",
    "icon": "lucide:github",
    "category": "dev",
    "installed": false,
    "env_keys": [],
    "oauth": true
  }
]
```
```

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

### Verify PocketPaw Installation

Source: https://pocketpaw.xyz/getting-started/installation

Runs PocketPaw to start the web dashboard. The dashboard can be accessed via `http://localhost:8888` in a web browser.

```bash
pocketpaw
# Or with uvuv
# uvuv run pocketpaw
```

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

### Configure Environment Variables

Source: https://pocketpaw.xyz/deployment/docker

Instructions for setting up the environment configuration file. Users must copy the example file and define host-specific variables like Ollama connection strings.

```bash
# Initialize .env file
cp .env.example .env

# Set Ollama host for Docker container
POCKETPAW_OLLAMA_HOST=http://ollama:11434

# Set custom port
POCKETPAW_PORT=9000 docker compose up -d
```

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

### Deep Work API

Source: https://pocketpaw.xyz/api/post-session-title

Endpoints for managing deep work sessions, including starting, pausing, resuming projects, getting plans, approving plans, and skipping tasks.

```APIDOC
## POST /api/post-deep-work-start

### Description
Starts a new deep work project.

### Method
POST

### Endpoint
/api/post-deep-work-start

### Parameters
#### Request Body
- **project_name** (string) - Required - The name of the project.
- **tasks** (array) - Optional - A list of tasks for the project.

### Request Example
```json
{
  "project_name": "API Documentation",
  "tasks": [
    "Write endpoint descriptions",
    "Format markdown",
    "Generate JSON"
  ]
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message.
- **project_id** (string) - The ID of the started project.

#### Response Example
```json
{
  "message": "Deep work project started successfully.",
  "project_id": "dw_proj_1"
}
```

## GET /api/get-deep-work-plan

### Description
Retrieves the current deep work plan.

### Method

```

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

### Install PocketPaw via Shell Script

Source: https://pocketpaw.xyz/llms-full.txt

Automated installation script for setting up the PocketPaw environment, including creating a dedicated system user and running the installer.

```bash
sudo useradd -m -s /bin/bash pocketpaw
curl -fsSL https://pocketpaw.xyz/install.sh | sh
```

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

### Tool Policy Configuration for MCP Servers

Source: https://pocketpaw.xyz/llms-full.txt

These examples demonstrate how to configure the tool policy for MCP servers using environment variables. They show how to allow all MCP tools, allow specific server tools, or deny a particular tool.

```bash
# Allow all MCP tools
export POCKETPAW_TOOLS_ALLOW="group:mcp"


# Allow specific server's tools
export POCKETPAW_TOOLS_ALLOW="mcp:filesystem:*"


# Deny a specific tool
export POCKETPAW_TOOLS_DENY="mcp:github:delete_repo"
```

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

### Deep Work API

Source: https://pocketpaw.xyz/api/get-memory-stats

Manage 'Deep Work' sessions, including starting, pausing, resuming projects, and managing plans and tasks.

```APIDOC
## POST /api/post-deep-work-start

### Description
Starts a new 'Deep Work' project.

### Method
POST

### Endpoint
/api/post-deep-work-start

### Parameters
#### Request Body
- **project_name** (string) - Required - The name of the project.
- **goal** (string) - Optional - The objective for this deep work session.

### Request Example
```json
{
  "project_name": "API Documentation",
  "goal": "Complete API reference for PocketPaw LLMs."
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message.
- **project_id** (string) - The ID of the started project.

#### Response Example
```json
{
  "message": "Deep work project started.",
  "project_id": "dw_proj_1"
}
```

## GET /api/get-deep-work-plan

### Description
Retrieves the current plan for a 'Deep Work' project.

### Method
GET

### Endpoint
/api/get-deep-work-plan

### Parameters
#### Query Parameters
- **project_id** (string) - Required - The ID of the project.

### Request Example
`/api/get-deep-work-plan?project_id=dw_proj_1`

### Response
#### Success Response (200)
- **plan** (object) - The project plan details.

#### Response Example
```json
{
  "plan": {
    "tasks": [
      "Task 1: Define page structure",
      "Task 2: Document channels API"
    ],
    "estimated_time": "2 hours"
  }
}
```

## POST /api/post-deep-work-approve

### Description
Approves the plan for a 'Deep Work' project.

### Method
POST

### Endpoint
/api/post-deep-work-approve

### Parameters
#### Request
```

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

### Install Ollama and Pull Model

Source: https://pocketpaw.xyz/llms-full.txt

This sequence first installs Ollama, a tool for running local LLMs, and then downloads the 'qwen2.5:7b' model. This enables the use of free, private AI models on your machine.

```bash
# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh


# Pull a model
ollama pull qwen2.5:7b
```

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

### Example Slash Command Usage (Shell)

Source: https://pocketpaw.xyz/channels/discord

Demonstrates how a user can interact with the PocketPaw bot using a slash command in Discord to query files.

```shell
/paw What files are in the home directory?
```

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

### Deep Work API

Source: https://pocketpaw.xyz/api/get-qr-code

Endpoints for managing Deep Work sessions, including starting, getting plans, approving, pausing, resuming, and skipping tasks.

```APIDOC
## POST /api/post-deep-work-start

### Description
Starts a new Deep Work session or project.

### Method
POST

### Endpoint
/api/post-deep-work-start

### Parameters
#### Request Body
- **project_name** (string) - Required - The name of the project.
- **goal** (string) - Required - The goal of the Deep Work session.

### Request Example
```json
{
  "project_name": "API Documentation",
  "goal": "Complete API reference for PocketPaw LLMs."
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating the session has started.
- **session_id** (string) - The ID of the started Deep Work session.

#### Response Example
```json
{
  "message": "Deep Work session started successfully.",
  "session_id": "dw_session_1"
}
```

## GET /api/get-deep-work-plan

### Description
Retrieves the plan for the current Deep Work session.

### Method
GET

### Endpoint
/api/get-deep-work-plan

### Parameters
#### Query Parameters
- **session_id** (string) - Optional - The ID of the Deep Work session.

### Request Example
`/api/get-deep-work-plan?session_id=dw_session_1`

### Response
#### Success Response (200)
- **plan** (array) - An array of tasks in the Deep Work plan.

#### Response Example
```json
{
  "plan": [
    {
      "task_id": "task_1",
      "description": "Document Channels API",
      "status": "pending"
    },
    {
      "task_id": "task_2",
      "description": "Document Sessions API",
      "status": "pending"
    }
  ]
}
```

## POST /api/post-deep-work-approve

### Description
Approves the current Deep Work plan or a
```

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

### Spotify Playlist Management Tool Example

Source: https://pocketpaw.xyz/llms-full.txt

Demonstrates how to use the spotify_playlist tool to manage playlists, specifically adding the current song to a favorites playlist. The example shows the user's request and the agent's confirmation.

```plaintext
User: Add the current song to my favorites playlist
Agent: [uses spotify_playlist] → Added "Bohemian Rhapsody" to "Favorites"
```

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

### Deep Work API

Source: https://pocketpaw.xyz/api/post-mcp-toggle

Endpoints for managing 'Deep Work' sessions, including starting, pausing, resuming projects, getting plans, approving plans, and skipping tasks.

```APIDOC
## POST /api/post-deep-work-start

### Description
Starts a new Deep Work project.

### Method
POST

### Endpoint
/api/post-deep-work-start

### Parameters
#### Request Body
- **project_name** (string) - Required - The name of the project to start.

### Request Example
```json
{
  "project_name": "Develop Feature X"
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating the project has started.

#### Response Example
```json
{
  "message": "Deep Work project started."
}
```
```

```APIDOC
## GET /api/get-deep-work-plan

### Description
Retrieves the current Deep Work plan.

### Method
GET

### Endpoint
/api/get-deep-work-plan

### Parameters
None

### Response
#### Success Response (200)
- **plan** (object) - An object detailing the current Deep Work plan and tasks.

#### Response Example
```json
{
  "plan": {
    "current_task": "Implement login functionality",
    "next_task": "Write unit tests",
    "estimated_time": "2 hours"
  }
}
```
```

```APIDOC
## POST /api/post-deep-work-approve

### Description
Approves the current Deep Work plan.

### Method
POST

### Endpoint
/api/post-deep-work-approve

### Parameters
None

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating the plan has been approved.

#### Response Example
```json
{
  "message": "Deep Work plan approved."

```