### Development Setup and Testing

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/README.md

Clone the repository, install development requirements, and run tests using nox. This is the standard setup for contributing to the project.

```bash
git clone https://github.com/loonghao/shotgrid-mcp-server.git
cd shotgrid-mcp-server
pip install -r requirements-dev.txt

# Run tests
nox -s tests
```

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

### Install shotgrid-mcp-server from Source

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/installation.md

Clone the repository and install the shotgrid-mcp-server package in editable mode.

```bash
git clone https://github.com/loonghao/shotgrid-mcp-server.git
cd shotgrid-mcp-server
pip install -e .
```

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

### Install ShotGrid MCP Server

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/getting-started.md

Install the shotgrid-mcp-server package using uv or pip. uv is recommended for faster installations.

```bash
# Using uv (recommended)
uv pip install shotgrid-mcp-server

# Or using pip
pip install shotgrid-mcp-server
```

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

### Production Deployment Entry Point

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Example `app.py` for production deployment, pre-configured with CORS middleware. Customize as needed for specific requirements.

```bash
uvicorn app:app --host 0.0.0.0 --port 8000 --workers 4
```

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

### Install and Run with Uvicorn

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Install the ShotGrid MCP server and deploy it using Uvicorn. Set necessary environment variables for ShotGrid connection details.

```bash
# Install
pip install shotgrid-mcp-server

# Set environment
export SHOTGRID_URL="..."
export SHOTGRID_SCRIPT_NAME="..."
export SHOTGRID_SCRIPT_KEY="..."

# Deploy with Uvicorn
uvicorn shotgrid_mcp_server.asgi:app --host 0.0.0.0 --port 8000 --workers 4
```

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

### Install shotgrid-mcp-server with uv

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/installation.md

Use uv pip to install the shotgrid-mcp-server package. This is the recommended method.

```bash
uv pip install shotgrid-mcp-server
```

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

### Install shotgrid-mcp-server with pip

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/installation.md

Use pip to install the shotgrid-mcp-server package.

```bash
pip install shotgrid-mcp-server
```

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

### Start MCP Server with Stdio Transport

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Launch the MCP server using the 'uvx' command with the 'stdio' transport mode for local client communication.

```bash
uvx shotgrid-mcp-server stdio
```

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

### Multi-Site Configuration Example

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Configure the ShotGrid MCP server to manage multiple ShotGrid sites from a single instance. Credentials and site URLs are specified per site using HTTP headers.

```json
{
  "mcpServers": {
    "site1": {
      "url": "http://server:8000/mcp",
      "transport": {
        "type": "http",
        "headers": {
          "X-ShotGrid-URL": "https://site1.shotgunstudio.com",
          "X-ShotGrid-Script-Name": "script1",
          "X-ShotGrid-Script-Key": "key1"
        }
      }
    },
    "site2": {
      "url": "http://server:8000/mcp",
      "transport": {
        "type": "http",
        "headers": {
          "X-ShotGrid-URL": "https://site2.shotgunstudio.com",
          "X-ShotGrid-Script-Name": "script2",
          "X-ShotGrid-Script-Key": "key2"
        }
      }
    }
  }
}
```

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

### Run Development Server with Hot Reload

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/README.md

Start the development server with hot reload enabled using 'uv run'. This command is useful for rapid development cycles.

```bash
uv run fastmcp dev src/shotgrid_mcp_server/server.py:mcp
```

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

### Run Advanced Custom ASGI Application

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Command to run an advanced ASGI application example that includes multiple middleware configurations like logging, rate limiting, CORS, and GZip compression.

```bash
uvicorn examples.custom_app:app --host 0.0.0.0 --port 8000 --workers 4
```

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

### Start MCP Server with HTTP Transport

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Run the MCP server with HTTP transport, specifying host and port for web deployments and remote access.

```bash
shotgrid-mcp-server http --host 0.0.0.0 --port 8000
```

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

### Orchestrate with Docker Compose

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Command to start the ShotGrid MCP service and optional Nginx reverse proxy using Docker Compose. Facilitates multi-container orchestration.

```bash
docker-compose up -d
```

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

### Docker Compose Deployment

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Manage the ShotGrid MCP Server and its dependencies using Docker Compose. Start services and view logs with simple commands.

```bash
# Start services
docker-compose up -d

# View logs
docker-compose logs -f
```

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

### ShotGrid MCP Server Configuration Example

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/demos/editor-setup.md

Use this JSON configuration in your editor's MCP settings to connect to the ShotGrid MCP server. Ensure you replace placeholder values with your actual ShotGrid URL and credentials.

```json
{
  "mcpServers": {
    "shotgrid": {
      "command": "uvx",
      "args": ["shotgrid-mcp-server"],
      "env": {
        "SHOTGRID_URL": "https://your-site.shotgunstudio.com",
        "SHOTGRID_SCRIPT_NAME": "your_script_name",
        "SHOTGRID_SCRIPT_KEY": "your_script_key"
      }
    }
  }
}
```

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

### Create ASGI App with Custom Middleware

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Create a custom ASGI application with specific middleware, such as CORSMiddleware, for enhanced security and request handling. This example demonstrates a simple CORS configuration.

```python
# app.py
from starlette.middleware import Middleware
from starlette.middleware.cors import CORSMiddleware
from shotgrid_mcp_server.asgi import create_asgi_app

app = create_asgi_app(
    middleware=[
        Middleware(CORSMiddleware, allow_origins=["https://yourdomain.com"])
    ]
)
```

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

### Run ASGI Tests

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Execute tests specifically for the ASGI implementation of the ShotGrid MCP server using pytest. This command assumes 'uv' is installed and configured for running tests.

```bash
# Run ASGI tests
uv run pytest tests/test_asgi.py -v
```

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

### Docker Build and Run

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Build a Docker image for the ShotGrid MCP server and run it as a container. Environment variables can be provided via an .env file.

```bash
# Build
docker build -t shotgrid-mcp-server .

# Run
docker run -p 8000:8000 --env-file .env shotgrid-mcp-server
```

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

### Docker Image Build and Run

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Build a Docker image for the ShotGrid MCP Server and run it as a container, exposing the necessary ports and environment variables.

```bash
# Build image
docker build -t shotgrid-mcp-server .

# Run container
docker run -p 8000:8000 \
    -e SHOTGRID_URL=...
    -e SHOTGRID_SCRIPT_NAME=...
    -e SHOTGRID_SCRIPT_KEY=...
    shotgrid-mcp-server
```

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

### Import create_asgi_app from Package

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Import the `create_asgi_app` function directly from the `shotgrid_mcp_server` package after it has been added to `__all__` exports.

```python
from shotgrid_mcp_server import create_asgi_app

app = create_asgi_app()
```

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

### Build and Run Docker Image

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Commands to build a Docker image for the ShotGrid MCP Server and run it as a container. Uses a multi-stage build for optimization and a non-root user for security.

```bash
docker build -t shotgrid-mcp-server .
docker run -p 8000:8000 --env-file .env shotgrid-mcp-server
```

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

### Migrate from HTTP to ASGI Deployment

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Compare the command-line arguments for running the ShotGrid MCP server in HTTP mode versus ASGI mode. ASGI deployment offers benefits like multiple workers and middleware support.

```bash
# Before (HTTP mode):
shotgrid-mcp-server http --host 0.0.0.0 --port 8000

# After (ASGI deployment):
# Option 1: Use default ASGI app
uvicorn shotgrid_mcp_server.asgi:app --host 0.0.0.0 --port 8000 --workers 4

# Option 2: Use custom app with middleware
uvicorn app:app --host 0.0.0.0 --port 8000 --workers 4
```

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

### Batch Create Assets & Assign Tasks Prompt

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/demos/batch-operations.md

Use this prompt to create multiple assets in batch, categorize them, apply task templates, and assign tasks with specified schedules. Ensure the project and user details are accurate for your environment.

```text
Batch create the recommended hero characters in the shotgrid Demo:Animation 
project, categorize them as characters, use the FilmVFX-CharacterAsset task 
template, assign tasks to Yang Zhuo, with start and end dates set to next week
```

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

### create_playlist

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/notes-playlists.md

Create a new playlist for review.

```APIDOC
## create_playlist

### Description
Create a new playlist for review.

### Parameters
#### Path Parameters
- `project_id` (number) - Required - Project ID
- `code` (string) - Required - Playlist name

#### Query Parameters
- `versions` (array) - Optional - Version IDs to include

### Example
Create a playlist called "Daily Review" with versions 100, 101, 102
```

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

### Configure ShotGrid Credentials

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/getting-started.md

Set your ShotGrid account credentials as environment variables. Ensure you replace the placeholder values with your actual ShotGrid URL, script name, and script key.

```bash
export SHOTGRID_URL="https://your-site.shotgunstudio.com"
export SHOTGRID_SCRIPT_NAME="your_script_name"
export SHOTGRID_SCRIPT_KEY="your_script_key"
```

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

### Production ASGI Deployment with Gunicorn

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Deploy the ShotGrid MCP Server using Gunicorn with Uvicorn workers for robust production environments. Configure host, port, and worker count.

```bash
# Using Gunicorn with Uvicorn workers
gunicorn shotgrid_mcp_server.asgi:app \
    -k uvicorn.workers.UvicornWorker \
    --bind 0.0.0.0:8000 \
    --workers 4
```

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

### Create Standalone ASGI Application

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Use `create_asgi_app` to generate a customizable ASGI application. Supports middleware injection and lazy initialization. Useful for simple deployments or when custom middleware is required.

```python
from shotgrid_mcp_server.asgi import create_asgi_app

# Simple deployment
app = create_asgi_app()

# With middleware
from starlette.middleware import Middleware
from starlette.middleware.cors import CORSMiddleware

app = create_asgi_app(
    middleware=[
        Middleware(CORSMiddleware, allow_origins=["*"])
    ],
    path="/mcp"
)
```

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

### Create ASGI App with Middleware

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Define and apply custom middleware to the ASGI application. Ensure middleware is ordered correctly for desired processing.

```python
from starlette.middleware import Middleware
from starlette.middleware.cors import CORSMiddleware
from shotgrid_mcp_server.asgi import create_asgi_app

middleware = [
    Middleware(CORSMiddleware, allow_origins=["*"]),
    Middleware(CustomAuthMiddleware),
    Middleware(LoggingMiddleware),
]

app = create_asgi_app(middleware=middleware)
```

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

### Local Development Deployment

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Use these commands to run the ShotGrid MCP Server in stdio or HTTP mode for local development and testing.

```bash
# Stdio mode for local clients
uvx shotgrid-mcp-server
```

```bash
# HTTP mode for testing
shotgrid-mcp-server http --host 127.0.0.1 --port 8000
```

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

### Deploy ASGI Application with Uvicorn

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Command to run the ASGI application using Uvicorn. Specify host, port, and number of workers for production deployment.

```bash
uvicorn shotgrid_mcp_server.asgi:app --host 0.0.0.0 --port 8000 --workers 4
```

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

### Production ASGI Deployment with Uvicorn

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Deploy the ShotGrid MCP Server using Uvicorn for production ASGI applications. Ensure the host and port are configured appropriately.

```bash
# Using Uvicorn
uvicorn shotgrid_mcp_server.asgi:app --host 0.0.0.0 --port 8000 --workers 4
```

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

### Create ASGI App with Middleware

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Define a list of middleware components to be applied to the ASGI application. This allows for adding functionalities like CORS, authentication, logging, and compression.

```python
middleware = [
    Middleware(CORSMiddleware, allow_origins=["*"]),
    Middleware(AuthMiddleware, api_key="secret"),
    Middleware(LoggingMiddleware),
    Middleware(GZipMiddleware),
]

app = create_asgi_app(middleware=middleware)
```

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

### Docker Compose Deployment

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Set up a .env file with ShotGrid credentials and deploy the ShotGrid MCP server using Docker Compose. This is useful for managing multi-container applications.

```bash
# Create .env file
echo "SHOTGRID_URL=..." > .env
echo "SHOTGRID_SCRIPT_NAME=..." >> .env
echo "SHOTGRID_SCRIPT_KEY=..." >> .env

# Deploy
docker-compose up -d
```

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

### Add Custom Middleware to ASGI App

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Configure custom middleware like CORS and GZip by passing a list of Middleware objects to the create_asgi_app function. Ensure correct origins are specified for CORS.

```python
from starlette.middleware import Middleware
from starlette.middleware.cors import CORSMiddleware
from starlette.middleware.gzip import GZipMiddleware
from shotgrid_mcp_server.asgi import create_asgi_app

middleware = [
    Middleware(CORSMiddleware, allow_origins=["https://yourdomain.com"]),
    Middleware(GZipMiddleware, minimum_size=1000),
]

app = create_asgi_app(middleware=middleware, path="/mcp")
```

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

### Run All Tests with Coverage

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Execute all tests for the ShotGrid MCP server and generate a coverage report. This helps in assessing the test coverage of the codebase.

```bash
# With coverage
uv run pytest tests/ -v --cov=shotgrid_mcp_server --cov-report=term-missing
```

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

### batch_create

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/batch.md

Create multiple entities at once by providing the entity type and a list of data objects.

```APIDOC
## batch_create

### Description
Create multiple entities at once.

### Parameters
#### Request Body
- **entity_type** (string) - Required - Entity type
- **data_list** (array) - Required - List of entity data objects

### Request Example
```
Create 10 shots named SH001 to SH010 in project 123
```
```

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

### Configure Stdio Transport Credentials

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Set environment variables for ShotGrid URL, script name, and script key when using Stdio transport for local MCP clients.

```bash
SHOTGRID_URL=https://your-site.shotgunstudio.com
SHOTGRID_SCRIPT_NAME=your_script
SHOTGRID_SCRIPT_KEY=your_key
```

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

### shotgrid.note.create

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/notes-playlists.md

Create a new note on an entity.

```APIDOC
## shotgrid.note.create

### Description
Create a new note on an entity.

### Parameters
#### Path Parameters
- `project_id` (number) - Required - Project ID
- `entity_type` (string) - Required - Linked entity type
- `entity_id` (number) - Required - Linked entity ID

#### Query Parameters
- `subject` (string) - Optional - Note subject
- `content` (string) - Required - Note content
- `addressings_to` (array) - Optional - Users to notify

### Example
Add a note to shot 456 saying "Animation approved, ready for lighting"
```

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

### Run Gunicorn with Uvicorn Workers

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Deploy the application using Gunicorn with Uvicorn workers for robust process management and concurrency.

```bash
gunicorn app:app -k uvicorn.workers.UvicornWorker --workers 4
```

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

### Run Uvicorn with Multiple Workers

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Deploy the application using Uvicorn with multiple worker processes to enhance concurrency and performance.

```bash
uvicorn app:app --workers 4
```

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

### Kubernetes Deployment

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Deploy the ShotGrid MCP Server to a Kubernetes cluster using a deployment configuration file. Check the status of deployed pods.

```bash
# Apply deployment
kubectl apply -f deployment.yaml

# Check status
kubectl get pods -l app=shotgrid-mcp-server
```

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

### Run ASGI Tests with Pytest

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Command to execute tests for the ASGI functionality using Pytest. Ensures correct behavior for app creation, path configuration, and middleware injection.

```bash
uv run pytest tests/test_asgi.py -v
```

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

### shotgrid.note.update

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/notes-playlists.md

Update an existing note.

```APIDOC
## shotgrid.note.update

### Description
Update an existing note.

### Parameters
#### Path Parameters
- `note_id` (number) - Required - Note ID

#### Query Parameters
- `content` (string) - Optional - New content
- `subject` (string) - Optional - New subject

### Example
Update note 789 with new content
```

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

### Run ShotGrid MCP Server with HTTP Transport

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/configuration.md

Configure the server to use HTTP transport for remote access or shared environments. Specify the host and port for the server to listen on.

```bash
uvx shotgrid-mcp-server http --host 0.0.0.0 --port 8000
```

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

### Run ShotGrid MCP Server with stdio Transport

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/configuration.md

Use the stdio transport for local MCP clients. This is the default transport option.

```bash
uvx shotgrid-mcp-server
```

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

### Run ShotGrid MCP Server with ASGI Transport

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/configuration.md

Deploy the ShotGrid MCP server using ASGI for production environments. This command is typically used with a production-grade ASGI server like uvicorn or gunicorn.

```bash
uvicorn shotgrid_mcp_server.asgi:app --host 0.0.0.0 --port 8000
```

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

### Set Environment Variables for ShotGrid

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/configuration.md

Set the required ShotGrid API credentials and optional proxy settings as environment variables. These are necessary for the server to connect to your ShotGrid instance.

```bash
# Required
export SHOTGRID_URL="https://your-site.shotgunstudio.com"
export SHOTGRID_SCRIPT_NAME="your_script_name"
export SHOTGRID_SCRIPT_KEY="your_script_key"

# Optional - Proxy settings
export SHOTGRID_HTTP_PROXY="http://proxy:8080"
export SHOTGRID_HTTPS_PROXY="https://proxy:8080"
```

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

### Configure HTTP Transport Credentials

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/ARCHITECTURE.md

Provide ShotGrid URL, script name, and script key via HTTP headers for HTTP transport, supporting web-based and remote access.

```http
X-ShotGrid-URL: https://site.shotgunstudio.com
X-ShotGrid-Script-Name: script_name
X-ShotGrid-Script-Key: api_key
```

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

### Prompt for WeCom Integration

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/demos/wecom-integration.md

This prompt outlines the core task of calculating department efficiency and sending the results to WeCom. It specifies the efficiency formula to be used.

```text
Calculate department efficiency and send the data to WeCom. 
Efficiency formula: Efficiency = Task bid / Timelog hours
```

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

### shotgrid.note.read

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/notes-playlists.md

Read a note's content.

```APIDOC
## shotgrid.note.read

### Description
Read a note's content.

### Parameters
#### Path Parameters
- `note_id` (number) - Required - Note ID

### Example
Read note 789
```

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

### create_entity

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/crud.md

Creates a new entity in ShotGrid. Requires the entity type and the data for the new entity.

```APIDOC
## create_entity

### Description
Create a new entity in ShotGrid.

### Parameters
#### Request Body
- **entity_type** (string) - Required - Entity type (Shot, Asset, Task, etc.)
- **data** (object) - Required - Entity data

### Example
```
Create a new shot called "SH001" in project 123
```
```

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

### Kubernetes Secret and Deployment

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/FEATURE_ASGI_SUMMARY.md

Create a Kubernetes secret to store ShotGrid credentials and apply a deployment configuration. This enables running the ShotGrid MCP server in a Kubernetes cluster.

```bash
# Create secret
kubectl create secret generic shotgrid-credentials \
    --from-literal=url="..." \
    --from-literal=script-name="..." \
    --from-literal=script-key="..."

# Deploy
kubectl apply -f deployment.yaml
```

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

### Configure MCP Client for HTTP Transport (Remote)

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/installation.md

Configure the MCP client to use HTTP transport for remote connections. Specify the URL of your MCP server.

```json
{
  "mcpServers": {
    "shotgrid": {
      "url": "http://your-server:8000/mcp",
      "transport": { "type": "http" }
    }
  }
}
```

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

### find_playlists

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/notes-playlists.md

Find playlists matching criteria.

```APIDOC
## find_playlists

### Description
Find playlists matching criteria.

### Parameters
#### Query Parameters
- `project_id` (number) - Optional - Filter by project
- `filters` (array) - Optional - Additional filters

### Example
Find all playlists in project 123
```

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

### batch_update

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/batch.md

Update multiple entities simultaneously by providing a list of update objects, each specifying the entity type, ID, and fields to update.

```APIDOC
## batch_update

### Description
Update multiple entities at once.

### Parameters
#### Request Body
- **updates** (array) - Required - List of update objects
  Each update object contains:
  - **entity_type**: Entity type
  - **entity_id**: Entity ID
  - **data**: Fields to update

### Request Example
```
Update status to "fin" for shots 100, 101, and 102
```
```

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

### batch_delete

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/batch.md

Delete multiple entities in a single API call by providing a list of entity references, each containing the entity type and ID.

```APIDOC
## batch_delete

### Description
Delete multiple entities at once.

### Parameters
#### Request Body
- **entities** (array) - Required - List of entity references
  Each entity reference contains:
  - **entity_type**: Entity type
  - **entity_id**: Entity ID

### Request Example
```
Delete shots 100, 101, and 102
```
```

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

### search_entities

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/crud.md

Searches for multiple entities that match the specified criteria. Supports filtering, field selection, sorting, and limiting results.

```APIDOC
## search_entities

### Description
Search for multiple entities matching criteria.

### Parameters
#### Request Body
- **entity_type** (string) - Required - Entity type
- **filters** (array) - Optional - Filter conditions
- **fields** (array) - Optional - Fields to return
- **order** (array) - Optional - Sort order
- **limit** (number) - Optional - Max results

### Example
```
Find all shots in project 123 with status "ip"
```
```

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

### update_entity

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/crud.md

Updates an existing entity in ShotGrid. Requires the entity type, its ID, and the data containing the fields to be updated.

```APIDOC
## update_entity

### Description
Update an existing entity.

### Parameters
#### Request Body
- **entity_type** (string) - Required - Entity type
- **entity_id** (number) - Required - Entity ID
- **data** (object) - Required - Fields to update

### Example
```
Update shot 456 status to "fin"
```
```

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

### Efficiency Formula Definition

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/guide/demos/wecom-integration.md

Defines the formula for calculating department efficiency and provides interpretation guidelines for the resulting percentage.

```text
Efficiency = Task Bid Hours / Actual Timelog Hours

- > 100%: Under budget (efficient)
- = 100%: On budget
- < 100%: Over budget (needs attention)
```

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

### delete_entity

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/crud.md

Performs a soft delete on an entity. Requires the entity type and the ID of the entity to be deleted.

```APIDOC
## delete_entity

### Description
Delete an entity (soft delete).

### Parameters
#### Request Body
- **entity_type** (string) - Required - Entity type
- **entity_id** (number) - Required - Entity ID

### Example
```
Delete shot 456
```
```

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

### find_one_entity

Source: https://github.com/loonghao/shotgrid-mcp-server/blob/main/docs/api/crud.md

Finds a single entity by its ID or a set of filter conditions. Optionally, specific fields can be requested.

```APIDOC
## find_one_entity

### Description
Find a single entity by ID or filters.

### Parameters
#### Request Body
- **entity_type** (string) - Required - Entity type
- **filters** (array) - Required - Filter conditions
- **fields** (array) - Optional - Fields to return

### Example
```
Find shot with ID 456
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.