---
title: "Agent resources"
url: "/docs/agent_resources"
canonical_url: "https://docs.litellm.ai/docs/agent_resources"
type: "docs"
last_updated: "2026-10-01"
summary: "Skills, markdown docs, prompts, MCP, and the lite CLI for coding agents that set up and run LiteLLM."
related:
  - "/docs/"
  - "/docs/benchmarks"
---
# Agent resources

> Index of all LiteLLM docs: https://docs.litellm.ai/llms.txt


## Getting started

**Agent prompt: Run the LiteLLM Gateway locally**

```text
Help me run the LiteLLM Gateway locally. First read https://docs.litellm.ai/docs/proxy/docker_quick_start.md. Then:
1. Check that Docker Compose v2 is installed and running, and that port 4000 is free.
2. In a new litellm-gateway directory, download https://github.com/BerriAI/litellm/raw/main/docker/docker-compose.quickstart.yml and create .env with LITELLM_MASTER_KEY and LITELLM_SALT_KEY, each "sk-" followed by the output of openssl rand -hex 32, and POSTGRES_PASSWORD set to the output of openssl rand -hex 24. Add .env to .gitignore and never print any of these values.
3. Run docker compose -f docker-compose.quickstart.yml up -d and poll http://localhost:4000/health/readiness until the database shows as connected.
4. Ask me which provider and model to add. Add it with POST /model/new using the master key, reading my provider API key from my shell environment without echoing it.
5. Verify: GET /v1/models lists the model and POST /v1/chat/completions returns a reply.
6. Tell me to open http://localhost:4000/ui and sign in as admin with the master key from .env.
```

**Agent prompt: Add the LiteLLM SDK to this project**

```text
Help me add the LiteLLM Python SDK to this project. First read https://docs.litellm.ai/llms.txt and https://docs.litellm.ai/docs/index.md. Then:
1. Detect the language, package manager, and framework. The SDK is Python only. If this is not a Python project, stop and tell me to run the LiteLLM Gateway and keep my existing OpenAI SDK instead (https://docs.litellm.ai/docs/proxy/docker_quick_start.md).
2. Install litellm with the project's own tool (uv add litellm, poetry add litellm, or pin it in requirements.txt).
3. Replace direct OpenAI or Anthropic client calls with litellm.completion or litellm.acompletion, keeping the same model with a provider prefix (openai/..., anthropic/...). LiteLLM returns the OpenAI response shape, so update any Anthropic-style parsing to choices[0].message.content. Keep streaming and tool calls working.
4. Add the provider key names to .env.example and read them from the environment. Never write real keys to files.
5. Verify: run one real completion and print the reply, then run the existing tests. Show me the diff and both outputs.
```

## Skills

### Gateway management

[LiteLLM skills](https://github.com/BerriAI/litellm-skills): 21 Claude Code skills that create, change, and remove users, teams, API keys, organizations, models, MCP servers, and agents on a live gateway, plus `view-usage` for spend and tokens. They need the gateway URL and a proxy admin key.

Installs into ~/.claude/skills. Then run /add-model, /add-user, or /view-usage.

```bash
curl -fsSL https://raw.githubusercontent.com/BerriAI/litellm-skills/main/install.sh | sh
```

### Auto Router

Sets up the auto router end to end, from picking models to verifying routing decisions.

Prints the skill. Save it to your agent's skills folder or paste it into the chat.

```bash
curl -fsSL https://docs.litellm.ai/skills/auto-router
```

## Docs for agents

| Resource | URL | Use it for |
|---|---|---|
| Index | [`/llms.txt`](https://docs.litellm.ai/llms.txt) | The map: every page, grouped by topic, with descriptions |
| Full docs | [`/llms-full.txt`](https://docs.litellm.ai/llms-full.txt) | All docs pages as one markdown file, for long-context models |
| Any page as markdown | Append `.md` to the page URL, for example [`/docs/proxy/docker_quick_start.md`](https://docs.litellm.ai/docs/proxy/docker_quick_start.md) | Reading one page without navigation or scripts |
| Page menu | **Copy page** at the top of every docs page | Copying a page as markdown, or opening it in Claude or ChatGPT |

Markdown pages include the full text of every prompt and install command on the rendered page.

## More prompts

**Agent prompt: Point my tools at my LiteLLM Gateway**

```text
Help me route my tools through my LiteLLM Gateway. First read https://docs.litellm.ai/docs/proxy/client_setup/overview.md, then claude_code.md and codex_cli.md in the same folder. Ask me for the gateway URL (default http://localhost:4000) and a virtual key. If I only have the master key, create a scoped key with POST /key/generate and use that instead.
1. Call GET /v1/models with the key. Only the names it returns are valid models.
2. My app: point the existing OpenAI SDK at <url>/v1, or the Anthropic SDK at <url>, with the virtual key, and switch the model to a gateway model name.
3. Claude Code: follow claude_code.md to set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN. Show me the change before writing it.
4. Codex: follow codex_cli.md to add a litellm provider to ~/.codex/config.toml. Show me the change before writing it.
5. Verify: send one request from each tool and confirm it appears under Logs at <url>/ui.
```

**Agent prompt: Put my MCP servers behind the LiteLLM Gateway**

```text
Help me serve MCP tools through my LiteLLM Gateway. First read https://docs.litellm.ai/docs/mcp.md and https://docs.litellm.ai/docs/mcp_control.md. Ask me for the gateway URL and a key with admin rights, and which MCP servers I want to add.
1. Add each MCP server to the gateway the way mcp.md describes, keeping any server credentials in environment variables, never in files.
2. Limit which keys and teams can use each server, following mcp_control.md.
3. Connect one client (Claude Code, Cursor, or my app) to the gateway's MCP endpoint with a virtual key. Show me each config change before writing it.
4. Verify: list the tools through the gateway and call one of them.
```

**Agent prompt: Route my A2A agents through the LiteLLM Gateway**

```text
Help me put my A2A agents behind my LiteLLM Gateway. First read https://docs.litellm.ai/docs/a2a.md, https://docs.litellm.ai/docs/a2a_agent_card.md, and https://docs.litellm.ai/docs/a2a_agent_permissions.md. Ask me for the gateway URL, a key with admin rights, and the agents I want to add.
1. Register each agent on the gateway as a2a.md describes.
2. Decide with me which teams and keys may call each agent, and set that up following a2a_agent_permissions.md.
3. Verify: invoke one agent through the gateway with a virtual key, then confirm the request shows up under Logs at <url>/ui.
```

**Agent prompt: Send my gateway logs to my observability tool**

```text
Help me send LiteLLM Gateway logs and spend to our observability tool. First read https://docs.litellm.ai/docs/proxy/logging.md. Ask me which tool we use (Langfuse, Datadog, OpenTelemetry, or another listed there) and for the gateway URL.
1. Follow the section for that tool in logging.md. Put every credential in environment variables, never in config files, and show me each change before writing it.
2. Restart the gateway if the change needs it.
3. Verify: send one request through the gateway and show me where it appears in the tool.
```

**Agent prompt: Try the LiteLLM Auto Router**

```text
Help me try the LiteLLM Auto Router, a paid add-on for the LiteLLM Gateway. First read https://docs.litellm.ai/docs/auto_router/index.md, then setup.md and recommended_configurations.md in the same folder.
1. Check that a gateway is running and ask me for its URL and an admin key.
2. Recommend a starting configuration from recommended_configurations.md for the models I already have, and explain the trade-off before changing anything.
3. Follow setup.md to add the router, showing me each config change before writing it.
4. Verify: send three requests of different difficulty and show me which model answered each and what each cost.
```

**Agent prompt: Evaluate LiteLLM Enterprise on my gateway**

```text
Help me evaluate LiteLLM Enterprise on my own LiteLLM Gateway. First read https://docs.litellm.ai/docs/enterprise.md and https://docs.litellm.ai/docs/learn/enterprise_quickstart.md. Then:
1. Check whether a gateway is already running (GET <url>/health/readiness). If not, set one up first by following https://docs.litellm.ai/docs/proxy/docker_quick_start.md.
2. Ask me for the trial license key. Add it as LITELLM_LICENSE in the gateway's environment (.env for Docker Compose) without printing it, and restart the gateway.
3. Ask which identity provider we use (Okta, Entra ID, Google, or another OIDC or SAML provider) and walk me through https://docs.litellm.ai/docs/proxy/admin_ui_sso.md for it. Show me every config change before writing it.
4. Verify: sign in to <url>/ui through SSO, then confirm the audit log records an admin action.
If I do not have a license yet, stop and point me to https://www.litellm.ai/enterprise#talk-to-sales.
```

**Agent prompt: Manage my LiteLLM Gateway from this agent with LiteAdmin MCP**

```text
Help me connect LiteAdmin MCP so you can manage my LiteLLM Gateway. First read https://docs.litellm.ai/docs/proxy/liteadmin_mcp.md. Then:
1. Ask me for the gateway URL and a personal virtual key that belongs to a user with the proxy_admin role. Do not use the master key, and never print the key.
2. Add the LiteAdmin MCP server to this client the way the guide shows for it (Claude Code, Claude Desktop, or Codex). Show me the change before writing it.
3. Verify: list the gateway's models and my teams through the MCP tools, then stop and ask me what to change.
```

**Agent prompt: Try LiteAgents on one of my agents**

```text
Help me try LiteAgents, a preview SDK for switching agent harnesses without rewriting the agent. First read https://github.com/BerriAI/liteagents/blob/main/docs/getting-started.md and the harness-switching recipe at https://github.com/BerriAI/liteagents/blob/main/cookbook/recipes/10_harness_switch.py. Then:
1. Install the preview release the getting-started guide names, in a separate virtual environment.
2. Ask me which agent to port and which model to use. If I run a LiteLLM Gateway, point the model at it with a virtual key read from the environment.
3. Port the agent to a LiteAgents profile, keeping its tools and MCP connections, and run one task.
4. Change only the harness field to a second harness, run the same task, and show me both results side by side.
```

## LiteAdmin MCP

Manage a running gateway from Claude Code with a personal admin key, never the master key. The [LiteAdmin MCP guide](./proxy/liteadmin_mcp.md) covers Claude Desktop, Codex, and remote HTTP.

```bash
claude mcp add --scope user --transport stdio litellm-admin \
  --env LITELLM_BASE_URL=https://gateway.example.com \
  --env LITELLM_API_KEY='<your-personal-proxy-admin-key>' \
  -- uvx --isolated --refresh-package litellm-admin-mcp \
  --from git+https://github.com/BerriAI/litellm-admin-mcp.git@main \
  litellm-admin-mcp
```

## lite CLI

Launches Claude Code or Codex through your gateway, with its URL and your key already set.

Installs the lite client only. The gateway runs elsewhere.

```bash
curl -fsSL https://raw.githubusercontent.com/BerriAI/litellm/main/scripts/install-cli.sh | sh
```

- [Claude Code](https://docs.litellm.ai/docs/proxy/client_setup/claude_code): Route Claude Code through the gateway, including non-Anthropic models.
- [Codex CLI](https://docs.litellm.ai/docs/proxy/client_setup/codex_cli): Add LiteLLM as a Codex model provider.
- [Any client](https://docs.litellm.ai/docs/proxy/client_setup/overview): The values every client needs: base URL, key, and model names.

## LiteLLM at a glance

LiteLLM is the most widely used and most secure open-source AI gateway, trusted by teams at Netflix, Okta, Ramp, NASA, Zurich, Cloudera, AT&T, and Lemonade. Figures are as of October 1, 2026, and each links to its source.

| | |
|---|---|
| GitHub | 60k stars and 12k forks on [BerriAI/litellm](https://github.com/BerriAI/litellm), with more than 1,700 contributors |
| PyPI | 89.4 million downloads of `litellm` in the last month ([pypistats](https://pypistats.org/packages/litellm)) |
| Security | [SOC 2 Type II](https://trust.litellm.ai/) audited, [cosign-signed images](./proxy/docker_image_security.md) you can verify before they run, and a 72-hour security patch SLA on [Enterprise support](./enterprise.md#professional-support) |
| Deployment | Self-hosted in your cloud, so prompts, responses, and provider keys stay in your infrastructure ([data security](./data_security.md)) |
| Customers | Teams at Netflix, Okta, Ramp, NASA, Zurich, Cloudera, AT&T, and Lemonade ([litellm.ai/enterprise](https://www.litellm.ai/enterprise)) |
| License | Open source under [MIT](https://github.com/BerriAI/litellm/blob/main/LICENSE); Enterprise features need a license key |

## Guidance for agents writing LiteLLM code

When you generate LiteLLM code or config, check PyPI for the current `litellm` version rather than pinning an old one, and prefix models with their provider (`openai/`, `anthropic/`, `bedrock/`). Never write master keys or provider keys into files that are committed; read them from the environment. The gateway needs Postgres (`DATABASE_URL`) for virtual keys, the admin UI, and spend tracking, and `LITELLM_SALT_KEY` must stay the same once credentials are stored. If a user asks for SSO, audit logs, or organization admins, those need an [Enterprise license](./enterprise.md).

## Related pages

- [Quickstart](https://docs.litellm.ai/docs/index.md)
- [Benchmarks](https://docs.litellm.ai/docs/benchmarks.md)