Skip to main content
skill CX Codex

llm-cli — Claude Code skill: process text across multiple LLM providers

Skill to process text and files through the llm CLI, supporting OpenAI, Anthropic, Google Gemini, and local Ollama models. Selects a model interactively, persists settings, and runs in chat or one-off mode.

MIT 235 installs ★ 414 updated 2026-11-07

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add glebis/claude-skills --skill llm-cli -a claude-code
Open on GitHub

What llm-cli does

llm-cli wraps the llm command-line tool inside your code editor. Write a prompt, the skill checks which providers are available by reading environment variables (OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY, OLLAMA_BASE_URL), shows a model picker if needed, and runs the request. It accepts model names directly (claude-sonnet-4.5, gpt-4o, gemini-2.5-pro) and short aliases (claude, gpt, gemini, ollama).

Two modes: fire-and-forget processing (read input, run through LLM, return output) and interactive chat with llm --interactive. The skill remembers your last model choice in ~/.claude/llm-skill-config.json and offers it as default next time. Handles stdin, file paths (.txt, .md, .json, .pdf, images), and inline text.

Requires the llm package installed—if missing, the skill will prompt you to run pip install llm. At least one active API key or a running Ollama instance on localhost is needed.

What it helps with

  • pick a model from multiple available providers and process text without switching tools
  • run the same input across different models side-by-side for comparison
  • start an interactive conversation with a specific model from inside the editor
  • offload processing to a local Ollama instead of cloud APIs

Example prompts for the agent

  • Analyze this function with Claude Opus
  • Start an interactive session using gemini-2.5-flash
  • Process this README through the fastest available model

How to install llm-cli

1Skills CLI (Vercel)

npx skills add glebis/claude-skills --skill llm-cli -a claude-code

2Manually: put the files in place

~/.claude/skills/llm-cli/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/llm-cli/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about llm-cli

How do I install llm-cli in Claude Code?

Run npx skills add glebis/claude-skills --skill llm-cli -a claude-code, then load the skill from ~/.claude/skills/llm-cli/SKILL.md.

What does llm-cli do?

It lets you process text or files through the llm CLI tool, picking a model from available providers (OpenAI, Anthropic, Google, Ollama). Works in one-off mode or as an interactive chat.

Which models does llm-cli support?

Any model available through llm: OpenAI (gpt-5, gpt-4o, o3), Anthropic (claude-sonnet-4.5, claude-opus-4.1), Google (gemini-2.5-pro, gemini-2.5-flash), and local models via Ollama (llama3.1, mistral-large-2, and more).

Source text

SKILL.md · MIT
---
name: llm-cli
description: Process textual and multimedia files with various LLM providers using the llm CLI. Supports both non-interactive and interactive modes with model selection, config persistence, and file input handling.
---

# LLM CLI Skill

## Purpose

This skill enables seamless interaction with multiple LLM providers (OpenAI, Anthropic, Google Gemini, Ollama) through the `llm` CLI tool. It processes textual and multimedia information with support for both one-off executions and interactive conversation modes.

## When to Use This Skill

Trigger this skill when:
- User wants to process text/files with an LLM
- User needs to choose between multiple available LLMs
- User wants interactive conversation with an LLM
- User needs to pipe content through an LLM for processing
- User wants to use specific model aliases (e.g., "claude-opus", "gpt-4o")

Example user requests:
- "Process this file with Claude"
- "Analyze this text with the fastest available model"
- "Start an interactive chat with OpenAI"
- "Use Gemini to summarize this document"
- "Chat mode with my local Ollama instance"

## Supported Providers & Models

### OpenAI
- **Latest Models (2025)**:
  - `gpt-5` - Most advanced model
  - `gpt-4-1` / `gpt-4.1` - Latest high-performance
  - `gpt-4-1-mini` / `gpt-4.1-mini` - Smaller, faster version
  - `gpt-4o` - Multimodal omni model
  - `gpt-4o-mini` - Lightweight multimodal
  - `o3` - Advanced reasoning
  - `o3-mini` / `o3-mini-high` - Reasoning variants

**Aliases**: `openai`, `gpt`

### Anthropic
- **Latest Models (2025)**:
  - `claude-sonnet-4.5` - Latest flagship model
  - `claude-opus-4.1` - Complex task specialist
  - `claude-opus-4` - Coding specialist
  - `claude-sonnet-4` - Balanced performance
  - `claude-3.5-sonnet` - Previous generation
  - `claude-3.5-haiku` - Fast & efficient

**Aliases**: `anthropic`, `claude`

### Google Gemini
- **Latest Models (2025)**:
  - `gemini-2.5-pro` - Most advanced
  - `gemini-3.5-flash-lite` - Default fast model
  - `gemini-2.5-flash-lite` - Speed optimized
  - `gemini-2.0-flash` - Previous generation
  - `gemini-2.5-computer-use` - UI interaction

**Aliases**: `google`, `gemini`

### Ollama (Local)
- **Popular Models**:
  - `llama3.1` - Meta's latest (8b, 70b, 405b)
  - `llama3.2` - Compact versions (1b, 3b)
  - `mistral-large-2` - Mistral flagship
  - `deepseek-coder` - Code specialist
  - `starcode2` - Code models

**Aliases**: `ollama`, `local`

## Workflow Overview

```
User Input (with optional model)
    ↓
Check Available Providers (env vars)
    ↓
Determine Model to Use:
  - If specified: Use provided model
  - If ambiguous: Show selection menu
  - Otherwise: Use last remembered choice
    ↓
Load/Create Config (~/.claude/llm-skill-config.json)
    ↓
Detect Input Type:
  - stdin/piped
  - file path
  - inline text
    ↓
Execute llm CLI:
  - Non-interactive: Process & return
  - Interactive: Keep conversation loop
    ↓
Save Model Choice to Config
```

## Features

### 1. Provider Detection
- Checks environment variables for API keys
- Suggests available LLM providers on first run
- Detects: `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GOOGLE_API_KEY`, `OLLAMA_BASE_URL`

### 2. Model Selection
- Accept model aliases (`gpt-4o`, `claude-opus`, `gemini-2.5-pro`)
- Accept provider aliases (`openai`, `anthropic`, `google`, `ollama`)
- Interactive menu when selection is ambiguous
- Remembers last used model in `~/.claude/llm-skill-config.json`

### 3. Input Processing
- Accepts stdin/piped input
- Processes file paths (detects: .txt, .md, .json, .pdf, images)
- Handles inline text prompts
- Supports multimedia files with appropriate encoding

### 4. Execution Modes

#### Non-Interactive (Default)
```bash
llm "Your prompt here"
llm --model gpt-4o "Process this text"
llm < file.txt
cat document.md | llm "Summarize"
```

#### Interactive Mode
```bash
llm --interactive
llm -i
llm --model claude-opus --interactive
```

### 5. Configuration
Persistent config location: `~/.claude/llm-skill-config.json`
```json
{
  "last_model": "claude-sonnet-4.5",
  "default_provider": "anthropic",
  "available_providers": ["openai", "anthropic", "google", "ollama"]
}
```

## Implementation Details

### Core Files
- `llm_skill.py` - Main skill orchestration
- `providers.py` - Provider detection & config
- `models.py` - Model definitions & aliases
- `executor.py` - Execution logic (interactive/non-interactive)
- `input_handler.py` - Input type detection

### Key Functions

#### `detect_providers()`
- Scans environment for provider API keys
- Returns dict of available providers

#### `get_model_selector(input_text, provider=None)`
- Returns selected model, showing menu if needed
- Respects `last_model` config preference

#### `load_input(input_source)`
- Handles stdin, file paths, or inline text
- Returns content string

#### `execute_llm(content, model, interactive=False)`
- Calls `llm` CLI with appropriate parameters
- Manages stdin/stdout for interactive mode

### Usage in Claude Code

When user invokes this skill, Claude should:
1. Parse input for model specification (e.g., `--model gpt-4o`)
2. Call skill with content and optional model parameter
3. Wait for provider/model selection if needed
4. Execute and return results
5. For interactive mode, maintain conversation loop

## Error Handling

- If no providers available: Suggest installing API keys
- If model not found: Show available models for chosen provider
- If llm CLI not installed: Suggest installation via `pip install llm`
- If file not readable: Fall back to treating as inline text

## Configuration

Users can pre-configure preferences:
```json
{
  "last_model": "claude-sonnet-4.5",
  "default_provider": "anthropic",
  "interactive_mode": false,
  "available_providers": ["openai", "anthropic"]
}
```

## Slash Command Integration

Support `/llm` command:
```
/llm process this text
/llm --interactive
/llm --model gpt-4o analyze this
```

© glebis · MIT · glebis/claude-skills

Similar skills

All skills for AI and ML →

From the same set51

The whole set →
fathom Skill to retrieve meetings, transcripts, AI summaries, and action items directly from Fathom API. Use it to sync meeting recordings and transcripts into your coding workflow. CX Codex +1 249installs github-gist A skill to quickly publish files and notes as GitHub Gist. Use it when you need to share code, create a shareable snippet link, or upload markdown without extra steps. CX Codex +1 246installs balanced Skill for multi-perspective analysis: surfaces merits, challenges logic, suggests alternatives. Triggers on /balanced or requests for honest feedback. CX Codex +1 243installs gws A skill to access Gmail, Calendar, Drive, Sheets, and other Google Workspace services from AI-coding environments. Requires the gws CLI tool and a valid Google API OAuth token. CX Codex +1 235installs granola Use this skill to retrieve Granola notes and transcripts, then save meeting notes to Obsidian. It suits workflows that need searchable records or follow-up analysis. CX Codex +1 234installs chrome-history chrome-history is a Claude Code skill that searches Chrome history in natural language and filters results by date, content type, and keywords. CX Codex +1 234installs meta Registers a /meta handler to run Claude Code Agent SDK sessions inside the telegram_agent directory and edit the bot from chat. CX Codex +1 228installs context-builder context-builder — a skill for Claude Code, Codex, Cursor and other platforms that generates interactive discovery prompts for AI transformation consulting. CX Codex +1 226installs

Project sponsors

Companies that keep this analytics open