Skip to content

c0ffee0wl/llm-linux-setup

BranchesTags

Repository files navigation

LLM Tools Installation Script for Linux

Automated installation script for Simon Willison's llm CLI tool and related AI/LLM command-line utilities for Debian-based Linux environments.

Features

  • ✅ One-command installation - Run once to install everything
  • ✅ Self-updating - Re-run to update all tools automatically
  • ✅ Provider choice - Configure either Azure OpenAI (enterprise) or Google Gemini (free tier)
  • ✅ Easy provider switching - Use --azure or --gemini flags to switch anytime
  • ✅ Command completion - Press Ctrl+N for AI command suggestions, Tab for llm autocompletion (Zsh)
  • ✅ Automatic session recording - Terminal history captured for AI context
  • ✅ AI-powered context retrieval - Query your command history with context or llm -T context
  • ✅ RAG document querying - Query your documents with llm rag using hybrid semantic+keyword search (llm-tools-rag)
  • ✅ Terminator Assistant - AI pair programming assistant with command execution (Terminator only)

System Requirements

  • OS: Debian, Ubuntu, Kali Linux (or derivatives)
  • Python: 3.8+ (usually pre-installed)
  • Rust: 1.85+ (automatically installed via rustup if not available)
  • Node.js: 20+ (automatically installed via nvm if repository version is older)
  • Internet: Required for installation and API access
  • Disk Space: ~500MB for all tools and dependencies

Supported Shells:

  • Zsh (5.0+) - Recommended
  • Bash (3.0+)

Note: The installation script automatically handles Rust and Node.js version requirements. If your system has older versions, it will offer to install newer versions via rustup and nvm respectively.

Recommended: For a fully configured Linux environment with optimized shell settings, security tools, and system utilities, consider installing linux-setup first. This provides the base configuration layer that complements the LLM tools.

Installation

Prerequisites (Recommended)

For the best experience, install linux-setup first to get a fully configured Linux environment:

git clone https://github.com/c0ffee0wl/linux-setup.git
cd linux-setup
./linux-setup.sh

The linux-setup repository provides:

  • Optimized Zsh configurations and aliases
  • Essential security and development tools
  • Base environment that complements LLM tools

This step is optional but recommended for the most complete setup.

Quick Start

sudo git clone https://github.com/c0ffee0wl/llm-linux-setup.git /opt/llm-linux-setup
sudo chown -R $(whoami):$(whoami) /opt/llm-linux-setup
cd /opt/llm-linux-setup
./install-llm-tools.sh

During first-time installation, you'll be prompted for:

  1. Provider Choice - Choose either Azure OpenAI (enterprise) or Google Gemini (free tier)
    • Azure: Prompts for API key and resource URL
    • Gemini: Prompts for API key (free from Google AI Studio)
  2. Session Log Storage - Choose between temporary (/tmp, cleared on reboot) or permanent (~/session_logs, survives reboots)

Note: To switch providers later, use the appropriate flag (--azure or --gemini).

Updating

Simply re-run the installation script:

cd /opt/llm-linux-setup
./install-llm-tools.sh

To switch or reconfigure providers:

# Switch to or reconfigure Azure OpenAI
./install-llm-tools.sh --azure

# Switch to or reconfigure Google Gemini
./install-llm-tools.sh --gemini

The script will:

  1. Pull the latest version of the repository (and itself) from git.
  2. Update llm, its plugins, and all applications installed by the llm-setup.
  3. Update custom templates (llm.yaml, llm-code.yaml).
  4. Refresh shell integration files.
  5. Preserve existing provider and session log configurations (unless switching providers).

Quick Reference

⚡ Most Common Commands (no need to specify -t llm - it's the default!)

# Ask questions (assistant template auto-applied)
llm "Your question here"
llm -c "Your follow up"     # Continue last conversation on CLI
llm chat                    # Start interactive conversation
llm chat -c                 # Continue last conversation interactively

# Include local context via shell expansion or piping
llm "explain this error: $(python zero_division.py 2>&1)"
docker logs -n 20 my_app | llm "check logs, find errors, provide possible solutions"

cat setup.py | llm 'extract the metadata'
llm 'extract the metadata' < setup.py     # Avoid useless use of cat
llm -f setup.py 'extract the metadata'    # Alternatively use local fragments

ls -1aG | llm "Describe each of the files"
llm "What does 'ls -1aG' do?"

# Use command completion (works best with Zsh)
# Type: find pdf files larger than 20MB
# Press: Ctrl+N

# Generate clean code ('llm code' is an alias for 'llm -t llm-code')
llm code "python function to..." | tee output.py

# You can iterate on generated code by continuing the last conversation
llm code "find files larger than 100MB as a bash script" | tee script.sh
llm code -c "and smaller than 500MB; add comments" | tee script.sh

# Use fragments for context
llm -f github:user/repo "analyze this"
llm -f pdf:document.pdf "summarize"
llm -f pdf:https://example.com/doc.pdf "summarize remote PDF"
llm -f yt:https://youtube.com/watch?v=VIDEO_ID "summarize video"
llm -f https://example.com "extract key points"

# Use -t when you want a DIFFERENT template than the default assistant template
llm -t fabric:summarize "..."        # Not the default
llm -t fabric:analyze_threat_report  # Not the default

# Git workflow - AI-powered commit messages
llm git-commit                       # Generate commit message from staged changes
llm git-commit --tracked             # Generate commit message from all tracked changes

# Semantic sorting - sort by meaning, not alphabetically
cat names.txt | llm sort --query "Which is more suitable for a pet monkey?"
llm sort --query "Most technical" --top-k 5 topics.txt

# Query your documents with RAG (llm-tools-rag hybrid search)
llm rag add mydocs /path/to/files # Add documents to collection
llm rag search mydocs "query"     # Search collection
llm -T 'rag("mydocs")' "question" # Use RAG as a tool in conversations

# Understand command output
wut                                  # Explain what just happened
wut "why did this fail?"             # Ask specific question about last command

# Web search with Google (requires Gemini/Vertex)
llm chat-google-search               # Interactive chat with Google Search grounding

# Query terminal history (context tool is built into assistant template!)
llm "what was the error in my last command?"   # Uses context tool automatically in default template
command llm -T context "..."                   # Explicit tool call (for non-assistant templates)
context                                        # Show last command
context 5                                      # Show last 5 commands

# Run shell commands safely (sandboxed_shell tool is built into assistant template!)
llm "Check if docker is installed and show version"   # AI runs commands safely, automatically
llm chat   # Then ask: "Can you list the files in /root?"
llm "Check kernel version" --td         # Show tool execution details
llm "Check kernel version" --ta         # Require manual approval before execution
command llm -T sandboxed_shell "..."    # Explicit tool call (for non-assistant templates)

# File manipulation (use -T Patch with --ta for safety)
llm -T Patch "Read config.yaml" --ta                           # Read files
llm -T Patch "Create hello.py with a hello world program" --ta # Create files
llm -T Patch "In config.yaml, change debug to true" --ta       # Edit files

# Terminator Assistant (AI terminal assistant)
llm assistant                     # Launch AI assistant in Terminator
llm assistant azure/gpt-4.1       # Launch with specific model
# Inside assistant:
#   /watch detect security issues                    # Security monitoring
#   /watch spot inefficient shell commands           # Shell efficiency tips
#   /watch monitor logs for errors and suggest fixes # Log monitoring
#   /help                                            # Show commands
#   /quit                                            # Exit

# Claude Code Router (multi-provider routing)
routed-claude                    # Launch Claude Code through router (alias for 'ccr code')

Documentation

This Project

  • README.md - Readme
  • CLAUDE.md - Developer documentation and architecture guide (for Claude Code and contributors)

Original Tools

What Gets Installed

Core Tools

  • llm - LLM CLI tool (fork with markdown markup enhancements, originally by Simon Willison - Documentation)
  • Claude Code - Anthropic's official agentic coding CLI
  • Claude Code Router - Multi-provider routing proxy for Claude Code (Azure + Gemini dual-provider or Gemini-only)

Necessary Prerequisites

  • Python 3 - Required for llm
  • uv - Modern Python package installer
  • Node.js - JavaScript runtime (v20+, from repositories or nvm)
  • Rust/Cargo - Rust toolchain (v1.85+, from repositories or rustup)
  • Go - Go toolchain (v1.22+, optional, for imagemage)
  • argc - Bash CLI framework and command runner (enables optional llm-functions integration)
  • bubblewrap - Sandboxing tool for llm-tools-sandboxed-shell
  • poppler-utils - PDF utilities (pdftotext for RAG)
  • pandoc - Document converter (DOCX support for RAG)
  • xsel - X11 clipboard tool (enables pbcopy/pbpaste on Linux)
  • jq - Command-line JSON processor

LLM Plugins

LLM Templates

  • llm.yaml - Custom assistant template with security/IT expertise configuration (Optimized for cybersecurity and Linux tasks, includes context and sandboxed_shell tools by default)
  • llm-code.yaml - Code-only generation template (outputs clean, executable code without markdown)
  • llm-wut.yaml - Command-line assistant for explaining terminal output and troubleshooting (concise 5-sentence responses, uses context tool automatically)
  • llm-assistant.yaml - AI pair programming template for Terminator terminal (provides intelligent debugging, command suggestions, and automatic execution in split panes)

Additional Tools

  • gitingest - Convert Git repositories to LLM-friendly text
  • yek - Fast repository to LLM-friendly text converter (230x faster than alternatives, written in Rust)
  • files-to-prompt - File content formatter for LLM prompts
  • asciinema - Terminal session recorder (built from source for latest features)
  • context - Terminal history extraction from asciinema recordings (CLI + LLM tool)
  • Micro - Modern terminal text editor with llm-micro plugin for in-editor AI assistance
  • imagemage - Gemini image generation CLI (requires Go 1.22+, only installed when Gemini is configured)
  • onnx-asr - Speech-to-text transcription using NVIDIA Parakeet TDT (25 European languages, auto-punctuation)
  • llm-assistant - TmuxAI-inspired AI assistant for Terminator terminal (automatic command execution, watch mode)

Shell Integration

  • AI-powered command completion (Ctrl+N) - see llm-integration.bash / .zsh
  • Tab completion for llm commands (Zsh only) - see llm-zsh-plugin
  • Custom llm wrapper with automatic template application - see llm-common.sh
  • Automatic session recording with asciinema - see llm-common.sh
  • macOS-style clipboard aliases (pbcopy/pbpaste via xsel on Linux)
  • Common aliases and PATH configuration

Usage

Getting Started

Discover your installation and available commands:

# Verify llm is installed and in PATH
which llm
command llm

# View general help
llm --help

# Get help for specific commands
llm prompt --help
llm chat --help

# View your assistant template configuration
xdg-open ~/.config/io.datasette.llm/templates/llm.yaml  # Linux
open ~/.config/io.datasette.llm/templates/llm.yaml  # macOS

# View installed plugins
llm plugins

Basic Prompts

💡 Important: All llm and llm chat commands automatically use the assistant template by default. You don't need to specify -t llm!

The assistant template is configured for security/IT expertise - perfect for cybersecurity and Linux tasks.

Simple question-and-answer prompts:

# Ask a question (per your assistant template)
# The assistant template is automatically applied
llm "Was ist das meistverbreite Betriebssystem für Pentester?"

# Continue the most recent conversation in CLI mode (--continue / -c)
llm -c "Und für Forensiker?"

# Include system information in your prompt
llm "Tell me about my operating system: $(uname -a)"

# Pipe output to clipboard
llm "Was ist das meistverbreite Betriebssystem für Pentester?" | pbcopy

Note: The shell integration provides macOS-style clipboard commands (pbcopy/pbpaste) on Linux via aliases to xsel.

Markdown Rendering (Fork Feature)

This llm fork includes markdown rendering capabilities using the rich library:

# Render output as beautifully formatted markdown
llm "Explain Docker in markdown format" --markdown

# Use the shorthand flag
llm "Create a bullet list of top 5 Linux commands" --md

# Works with piping too
cat article.txt | llm "Summarize in markdown" --md

The --markdown/--md flags provide:

  • Syntax-highlighted code blocks
  • Formatted tables, lists, and headers
  • Better readability in the terminal

Interactive Chat Mode

Continue a conversation with context (assistant template is auto-applied to new chats):

# Start a new chat conversation (assistant template auto-applied)
llm chat

# Continue the most recent conversation (template not re-applied)
llm chat -c

Help Documentation Queries

A powerful workflow is piping command help output to llm for natural language questions, then continuing the conversation:

# Ask questions about command options
bat --help | llm "What is the difference between '| bat -p -l md' and '| bat --language=markdown --force-colorization'?"

# Continue asking follow-up questions in a chat (don't pipe directly to 'llm chat'!)
docker --help | llm
llm chat -c --md
# > What's the difference between 'docker run' and 'docker exec'?
# > When should I use '--detach' vs '--interactive'?

# Get explanations for complex commands
git --help | llm "Explain git rebase in simple terms"
llm -c "Now explain the difference between rebase and merge"

The -c (continue) flag lets you maintain context and ask follow-up questions without re-sending the help text.

Understanding Command Output (wut)

The wut command is a command-line assistant that explains terminal output and helps troubleshoot issues. It automatically accesses your terminal history to understand what went wrong and provides expert analysis with actionable fixes.

Basic Usage:

# Run a command that produces output or errors
docker build -t myapp .
# Error: failed to solve with frontend dockerfile.v0

# Ask what happened (automatic explanation)
wut
# AI explains the docker build error, identifies the root cause, and suggests a fix

# Ask a specific question
npm install
# Warning: deprecated packages...

wut "are these deprecation warnings a security issue?"
# AI analyzes the warnings and provides security context

# Interactive troubleshooting mode
wut
# Then continue with follow-up questions using: llm chat -c

How It Works:

  • Automatic context: Uses the context tool to access your terminal history automatically
  • Concise responses: Maximum 5 sentences unless the issue is complex
  • Expert analysis: Applies security/IT best practices to recommendations
  • Two modes:
    • Explain mode: wut (no arguments) explains what happened with your last command
    • Answer mode: wut "question" answers your specific question about the output

Use Cases:

# Debug failed builds
cargo build
# Error: cannot find crate...
wut "how do I fix this dependency issue?"

# Understand API errors
curl https://api.example.com/endpoint
# HTTP 403 Forbidden
wut

# Analyze logs
journalctl -xe | tail -20
wut "what caused this service to crash?"

# Diagnose permission issues
mkdir /var/myapp
# Permission denied
wut "how do I create this directory properly?"

💡 Pro tip: The wut command uses the same expert assistant template as llm chat, so it understands your technical environment (Linux, security tools, development workflow).

Command Completion

Type a partial command or describe what you want in natural language, then press Ctrl+N:

# Type: list all pdf files
# Press Ctrl+N
# Result: find . -type f -name "*.pdf"

# Type: Wie finde ich alle .sh-Dateien unter /root?
# Press Ctrl+N
# Result: find /root -name "*.sh"
# Don't execute it yet.
# Type: Aber nur auf demselben Dateisystem.
# Result: find /root -name "*.sh" -xdev

The AI will suggest a command and execute it after your approval.

You can also use llm cmd to suggest a command and leave you to modify and execute it.

# Generate a shell command
llm cmd "Find all .sh files below /root"

Attachments & Multi-modal

Some models support images, PDFs, audio, and video as input:

# Attach an image from URL
llm "Beschreibe" -a https://www.corporate-trust.de/wp-content/uploads/2023/12/poster_ransomware.pdf
llm "Wenn ich nur eines mache, was ist dann das wichtigste?" -c

# Attach local images
llm "Extrahiere den Text" -a image1.jpg -a image2.jpg

# Pipe content and attach it
wget https://www.corporate-trust.de/wp-content/uploads/2023/12/poster_ransomware.pdf -O poster.pdf
cat poster.pdf | llm 'describe image' -a -

Note: The -a - flag reads attachment data from stdin.

⚠️ Azure OpenAI Limitation: Azure models support image attachments but NOT PDF attachments. See Azure-Specific Limitations for workarounds.

Fragments

Fragments are reusable pieces of context that can be loaded into your prompts. They can be files, URLs, GitHub repositories, or PDFs.

For more details, see the official fragments documentation.

File and URL Fragments

Load local files or fetch content from URLs:

# Load a local file as context
llm -f /path/to/file.py "Explain this code"
# Simple alternative without local fragment
llm "Explain this code" < /path/to/file.py

# Load content directly from a URL (raw fetch)
llm -f https://example.com/article "Summarize this article"

# Combine multiple fragments (great for comparing files)
llm chat -f https://raw.githubusercontent.com/offsh/terminator_logger/refs/heads/master/auditor.py \
         -f https://raw.githubusercontent.com/gnome-terminator/terminator/refs/heads/master/terminatorlib/plugins/logger.py

# Then ask in the chat
# > Was ist der Unterschied zwischen den beiden Implementierungen?

💡 URL Fragment Types: -f https://url vs -f site:https://url

There are two ways to fetch web content:

  1. Direct URL fetch (-f https://url):

    • Fetches the URL content directly (raw)
    • Best for: APIs, JSON endpoints, raw files, GitHub raw content, RSS feeds
    • Gets exactly what the URL returns (HTML, JSON, plain text, etc.)

  2. Smart web extraction (-f site:https://url):

    • Uses the llm-fragments-site-text plugin
    • Intelligently extracts main content from HTML pages
    • Converts to clean markdown
    • Best for: Blog posts, articles, documentation pages, news sites

When to use which:

# ✅ Direct fetch for raw content and APIs
llm -f https://api.github.com/repos/user/repo "What's the star count?"
llm -f https://raw.githubusercontent.com/user/repo/main/script.py "Explain this code"

# ✅ Smart extraction for web pages with lots of HTML
llm -f site:https://example.com/blog/article "Summarize the main points"
llm -f site:https://docs.example.com/guide "Extract the installation steps"

# ❌ Don't use site: for raw content (it's already clean)
# llm -f site:https://api.github.com/repos/user/repo  # Unnecessary
# llm -f site:https://raw.githubusercontent.com/...   # Unnecessary

GitHub Repository Fragments

Load entire GitHub repositories or specific issues/PRs (powered by llm-fragments-github):

# Load an entire repository
llm -f github:Softeria/ms-365-mcp-server \
    "Wo wird da die App / der Dienstprinzipal konfiguriert in welcher Quelltextdatei?"

# Continue the conversation
llm chat -c
# > Was muss ich machen, wenn ich selbst so eine App in meinem Tenant anlegen möchte?

# Compare two similar projects
llm -f github:space-cadet/yt-mcp \
    "Kann dieser MCP-Server Playlisten beliebiger länge abfragen, oder gibt es ein hartkodiertes Limit?"

llm -c -f github:emit-ia/youtube-transcript-mcp \
    "Und jetzt im Vergleich dieser. Was sind da die Unterschiede? Der letzte erfordert keinen API-Key, oder wie macht er das?"
    
# Load a specific GitHub issue
llm -f issue:simonw/llm/123 "Summarize this issue"

# Load a pull request with diff
llm -f pr:simonw/llm/456 "Review this PR"

PDF Fragments

For models that don't support native PDF attachments, use the pdf: fragment type:

wget https://www.corporate-trust.de/wp-content/uploads/2023/12/poster_ransomware.pdf -O poster.pdf

# Load a PDF as context
# Alternative to using -a for PDFs (converts to markdown first)
llm -f pdf:poster.pdf "Was ist das wichtigste auf diesem Poster?"

YouTube Video Fragments

Extract transcripts and metadata from YouTube videos using the yt: fragment type:

# Summarize a YouTube video
llm -f yt:https://www.youtube.com/watch?v=VIDEO_ID "Summarize this video"

# Extract key points from a video
llm -f yt:https://youtu.be/VIDEO_ID "What are the main topics discussed?"

# Analyze video content with fabric pattern
llm -f yt:https://www.youtube.com/watch?v=VIDEO_ID -t fabric:youtube_summary --md
llm -f yt:https://www.youtube.com/watch?v=VIDEO_ID -t fabric:summarize_lecture --md

# Compare multiple videos
llm -f yt:https://www.youtube.com/watch?v=VIDEO_ID_1 \
    -f yt:https://www.youtube.com/watch?v=VIDEO_ID_2 \
    "Compare these two videos and highlight the differences"

Note: The plugin uses yt-dlp for metadata extraction and youtube-transcript-api for transcript retrieval. Auto-generated captions are used if manual transcripts aren't available.

arXiv Paper Fragments

Access and analyze arXiv papers using the arxiv: fragment type or the llm arxiv command:

# Load an arXiv paper by ID
llm -f arxiv:2310.06825 "Summarize the key findings"

# Search for papers on a topic
llm arxiv-search "transformer architecture" -n 5

# Fetch and analyze a specific paper
llm arxiv 2310.06825 "What methodology was used?"

# Include figures from PDF (requires vision model)
llm arxiv 2310.06825 -i all -m gemini-2.5-flash "Describe the architecture diagram"

# Include specific pages' images
llm arxiv 2310.06825 -i P:1,3-5 "What does Figure 1 show?"

# Compare multiple papers
llm -f arxiv:2310.06825 -f arxiv:2401.12345 "Compare the approaches in these papers"

Features:

  • Fragment loader for embedding paper content in prompts
  • Image extraction from PDFs with page control (-i P:1,3-5 or -i all)
  • Search by keywords, author, or title
  • Resize images for token management (-r 800 for max 800px dimension)

Directory Fragments

Load all text files from a local directory recursively using the dir: fragment type:

# Load all text files from a directory
llm -f dir:/path/to/project "Analyze the structure of this codebase"

# Load from current directory
llm -f dir:. "Summarize all documentation files in this project"

# Combine with other fragments
llm -f dir:./docs -f dir:./src "Compare documentation with implementation"

# Use in interactive mode
llm chat -f dir:/etc/nginx/conf.d
# > Explain the nginx configuration
# > What security settings are configured?

What's included:

  • Recursively includes all text files from the specified directory
  • Automatically skips binary files
  • Useful for analyzing local codebases, documentation, or configuration directories

Tip: For large directories, consider using more specific paths or combining with other tools like gitingest, files-to-prompt, or yek for better control over file selection.

Templates

Templates are pre-configured prompt patterns that you can reuse. This setup includes custom templates and Fabric patterns.

💡 Reminder: The assistant template is already the default - you only need -t for different templates!

Using Templates

# ❌ Don't do this (assistant is already default)
# llm -t llm "Your question here"

# ✅ Just use llm directly for the default assistant template
llm "Your question here"

# ✅ Use -t when you want a DIFFERENT template
llm -t fabric:summarize -f https://github.com/c0ffee0wl/llm-linux-setup

Fabric Templates

The llm-templates-fabric plugin provides access to Fabric patterns:

# Summarize content
llm -f site:https://example.com/article -t fabric:summarize

# Explain code using Fabric's explain_code pattern
llm -f github:TheR1D/shell_gpt -t fabric:explain_code

# Analyze email headers for phishing detection
llm -f email_headers.txt -t fabric:analyze_email_headers

# Analyze a threat report
llm -f https://www.volexity.com/blog/2025/04/22/phishing-for-codes-russian-threat-actors-target-microsoft-365-oauth-workflows/ \
    -t fabric:analyze_threat_report

# Review code architecture
llm -f github:user/repo -t fabric:review_code

# Create STRIDE threat model
llm -f github:user/secure-app -t fabric:create_stride_threat_model

# Analyze malware samples and extract IOCs
llm -f malware_report.txt -t fabric:analyze_malware

# Structure incident/breach analysis
llm -f breach_article.md -t fabric:analyze_incident

# Generate network threat landscape from port scan
nmap -sV scanme.nmap.org | llm -t fabric:create_network_threat_landscape

Suggested Fabric Patterns:

For a complete list of available patterns, see the Fabric Pattern Explanations.

Creating Custom Templates

You can create your own templates to customize AI behavior for specific tasks. Templates are YAML files stored in ~/.config/io.datasette.llm/templates/.

Quick Start:

# Create a simple template for a user prompt
llm 'Summarize the following: ' --save summarize

# Create a system prompt
llm --system 'Summarize this' --save summarize

# Create a new template file
cat > ~/.config/io.datasette.llm/templates/mytemplate.yaml <<'EOF'
system: |
  You are a helpful assistant specialized in database design.
  Always provide SQL examples when relevant.
  Use PostgreSQL syntax by default.
EOF

# Use your template
llm -t mytemplate "How do I create an index on multiple columns?"

Template Components:

Templates support these fields:

  • system: System prompt that defines the AI's role and behavior
  • model: Default model to use (e.g., azure/gpt-4.1, gemini-2.5-flash)
  • tools: List of tools to make available (e.g., context, sandboxed_shell)
  • options: Model parameters (temperature, max_tokens, etc.)

Using Templates:

# Use custom template
llm -t mytemplate "Your user prompt here"

# List all available templates
llm templates

# Show template details
llm templates show mytemplate

For complete template documentation, see the LLM Templates Guide.

Git and Sorting

AI-Powered Commit Messages with llm-git-commit

Generate conventional commit messages using AI that analyzes your Git diffs:

# Generate commit message for staged changes
llm git-commit

# Generate commit message for all tracked changes
llm git-commit --tracked

# Interactive workflow:
# 1. AI analyzes your diff and generates a commit message
# 2. Review the suggested message
# 3. Press Ctrl+I to refine the message via chat
# 4. Use /apply to accept or /cancel to discard
# 5. Confirm before committing
# 6. Optionally push after commit

Features:

  • Conventional commit format: Follows industry-standard commit message conventions
  • Interactive refinement: Press Ctrl+I to chat with AI and improve the message
  • Safe workflow: Always shows preview and requires confirmation before committing
  • Context-aware: Analyzes actual code changes to generate meaningful messages

Example session:

$ git add src/api.py
$ llm git-commit

Analyzing changes...
Suggested commit message:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
feat: add user authentication endpoint

- Implement JWT token generation
- Add password hashing with bcrypt
- Create /api/login route with validation
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[A]ccept, [E]dit, [R]egenerate, or [C]ancel? a
Committing...
[main 1a2b3c4] feat: add user authentication endpoint
 1 file changed, 45 insertions(+)

Push changes? [y/N]

Semantic Sorting with llm-sort

Sort items by meaning rather than alphabetically using LLM-powered semantic comparisons:

# Sort items by semantic criteria
llm sort --query "Which is more suitable for a pet monkey?" names.txt

# Sort with piped input
cat programming_languages.txt | llm sort --query "Which is better for web development?"

# Use a different method, limit the output to the top 5 lines, and specify a custom model and prompt:
llm sort --query "Rank these slogans" --method sliding --top-k 5 --model azure/gpt-4.1 \
  --prompt 'Decide which line is more compelling. Answer with "Line A" or "Line B" Query: {query} Lines: {docA} {docB}.' quotes.txt

Use Cases:

  • Prioritization: "Which task is more urgent?" "Which feature provides more value?"
  • Recommendations: "Which book should I read to learn Python?" "Which tool is better for this task?"
  • Categorization: "Which item is more technical?" "Which concept is more advanced?"
  • Quality ranking: "Which code solution is cleaner?" "Which explanation is clearer?"

How it works:

llm-sort uses pairwise LLM comparisons to determine semantic ordering. Unlike alphabetical sorting, it understands context and meaning, making it ideal for subjective or context-dependent sorting tasks.

Options:

  • --query: The semantic criterion for sorting (required)
  • --method: Ranking approach (sorting or sliding, default: sorting)
  • --top-k: Limit output to top N results
  • --model: Specify which LLM model to use
  • --prompt: Custom comparison prompt template

Text Classification with llm-classify

Classify text into user-defined categories with confidence scores using LLM logprobs:

# Basic sentiment classification
echo "This is exciting news!" | llm classify -c positive -c negative -c neutral

# Multi-item classification
llm classify "I love this" "This is terrible" -c positive -c negative -c neutral

# Few-shot learning with examples
llm classify "Stock market crashed" -c economic -c political -c environmental \
  -e "Trade deal:economic" -e "Election:political"

# Custom model
llm classify "Analyze this" -c spam -c ham -m gpt-4o

Output Format: Results are returned as JSON arrays with class, score (0-1 confidence), and content.

Use Cases:

  • Content moderation: Classify user content as appropriate/inappropriate
  • Sentiment analysis: Categorize reviews as positive/negative/neutral
  • Topic routing: Route support tickets to appropriate departments
  • Intent detection: Classify user queries by intent type

Multi-Model Consensus with llm-consortium

Orchestrate multiple language models to collaboratively solve problems through parallel reasoning. Based on Karpathy's concept that asking all models and getting them to reach consensus produces optimal performance on complex problems:

# Simple query with default models
llm consortium "Your complex question here"

# Advanced: multiple model instances with custom arbiter
llm consortium "Analyze this security vulnerability" \
  -m o3-mini:1 -m gpt-4o:2 \
  --arbiter claude-3-opus-20240229 \
  --confidence-threshold 0.9 \
  --max-iterations 4

# Save configuration for reuse
llm consortium "Query" --save my-consortium
llm -m my-consortium "Use saved config"

# Continue conversations
llm -m my-consortium "Initial prompt"
llm -c "Follow-up question"

Key Options:

  • --arbiter: Judge model for evaluating responses (default: claude-3-opus)
  • --confidence-threshold: Target confidence level 0.0-1.0 (default: 0.8)
  • --max-iterations: Maximum refinement rounds (default: 3)
  • -m model:count: Specify model with instance count (e.g., gpt-4o:2)

Use Cases:

  • Complex reasoning: Math proofs, logic puzzles, code review
  • High-stakes decisions: Security analysis, legal review
  • Verification-heavy tasks: Fact-checking, data validation
  • Research synthesis: Combining perspectives from multiple models

Code Generation

Generate clean, executable code without markdown formatting using the llm code command (a convenient shorthand for llm -t llm-code).

The code template outputs pure code without explanations or markdown blocks, making it perfect for piping to files or direct execution. It infers the scripting/programming language from context, but it is better explicitly state it.

Examples:

# Generate bash script
llm code "Bash script to backup directory with timestamp" | tee backup.sh

# Pass existing code and modify it
cat fizz_buzz.py | llm code "Generate comments for each line of my code" | sponge fizz_buzz.py

# You can iterate on generated code by continuing the last conversation
llm code "find files larger than 100MB as a bash script" | tee script.sh
llm code -c "and smaller than 500MB; add comments" | tee script.sh

# Direct execution (use with caution!)
llm code "one-liner to find files larger than 100MB in Bash" | bash

# Generate Python function
llm code "solve classic fizz buzz problem using Python" | tee fizz_buzz.py

# Generate SQL query (prints to stdout)
llm code "SQL select users who registered this month"

# Generate configuration file
llm code "nginx config for reverse proxy on port 3000" | tee nginx.conf

# Generate Dockerfile
llm code "dockerfile for nodejs app with nginx" | tee Dockerfile

# Generate regex pattern
llm code "regex to match email addresses"

💡 Tip: Examples use | tee filename instead of > filename to provide visual feedback - you'll see the generated code in your terminal while it's also being saved to the file. This helps verify the output before using it.

Process Substitution (Execute Without Saving)

Use Bash/Zsh process substitution <(command) to execute generated code as a temporary file:

# Execute Python code directly without creating files
python <(llm code "Python function to calculate fibonacci, then print first 10 numbers")

How it works: The <(command) syntax creates a temporary file descriptor that Python or any other program reads as if it were a regular file, then automatically cleans up when done.

⚠️ Security Warning: Only use with trusted prompts. Generated code executes immediately with your user permissions. Review output first for sensitive operations:

# Safer: Review before executing
llm code "Python script to delete old files" | tee cleanup.py
# Review cleanup.py, then: python cleanup.py

Advanced Code Generation

Use fragments to provide context for code generation, enabling sophisticated plugin development and code transformations:

Plugin Development with Repository Context

Generate complete plugins by providing reference implementations as context:

# Develop a new llm plugin using an existing plugin as reference
llm code -m openai/o4-mini \
  -f github:simonw/llm-hacker-news \
      'write a new plugin called llm_video_frames.py which takes video:path-to-video.mp4
      and creates a temporary directory which it then populates with one frame per second
      of that video using ffmpeg - then it returns a list of
      [llm.Attachment(path="path-to-frame1.jpg"), ...]
      - it should also support passing video:video.mp4?fps=2 to increase to two frames per second,
      and if you pass ?timestamps=1 or &timestamps=1 then it should add a text timestamp to the
      bottom right corner of each image with the mm:ss timestamp of that frame (or hh:mm:ss if
      more than one hour in) and the filename of the video without the path as well.' \
  -o reasoning_effort high

# Generate a fragments plugin using reference code
llm -m claude-sonnet-4.5 \
  -f https://raw.githubusercontent.com/simonw/llm-hacker-news/refs/heads/main/llm_hacker_news.py \
  -f https://raw.githubusercontent.com/simonw/tools/refs/heads/main/github-issue-to-markdown.html \
  -s 'Write a new fragments plugin in Python that registers issue:org/repo/123 which fetches
      that issue number from the specified github repo and uses the same markdown logic as the
      HTML page to turn that into a fragment'

Code Transformation and Modernization

Use fragments to provide existing code as context for transformations:

# Convert setup.py to modern pyproject.toml
llm code -f setup.py "convert to pyproject.toml" -m claude-sonnet-4.5 | tee pyproject.toml

Using Multiple Fragments for Complex Tasks

Combine documentation, code, and requirements:

# Generate code with full project context
llm code \
  -f github:user/project \
  -f requirements.txt \
  -f docs/API.md \
  "Create a Python client library for this API with async support"

# Refactor code using style guide
llm code \
  -f existing_module.py \
  -f CONTRIBUTING.md \
  "Refactor this module to match our style guide, add type hints and docstrings"

Workflow Tips

  • Use reasoning models (-m openai/o4-mini -o reasoning_effort high) for complex plugin development
  • Provide reference code via fragments to establish patterns and coding style
  • Leverage GitHub fragments (-f github:org/repo) to quickly pull in reference implementations
  • Use -s (system prompt) to override the code template when you need additional context or explanations
  • Combine with -c to iterate: generate initial code, review, then refine with follow-up prompts

Tools

LLM supports tools that AI models can call during conversations.

Sandboxed Shell Execution

💡 Important: The sandboxed_shell tool is built into the assistant template by default! You can ask AI to run commands naturally without specifying -T sandboxed_shell every time.

Execute shell commands safely in an isolated environment using bubblewrap (bwrap):

# ✅ Ask AI naturally - sandboxed_shell tool is automatically available
llm "Check if docker is installed and show version"
llm chat
# > Can you list the files in /root?
# > Which kernel am I using?

# ⚠️ Explicit tool invocation (useful for non-assistant templates)
command llm -T sandboxed_shell "Run this command safely: cat /etc/passwd"

# Show tool execution details with --td flag
llm "Check if docker is installed" --td

# Manually approve each tool execution with --ta flag
llm "Check if docker is installed" --ta

# Combine both to see details AND approve
llm "Check if docker is installed" --td --ta

The --td flag shows full details of tool executions. The --ta flag requires manual approval before each tool execution.

Security Benefits:

  • Isolation: Commands run in a restricted environment using Linux namespaces
  • Read-only root: System directories are mounted read-only
  • No network access: Sandboxed commands cannot access the network by default

Note: Requires bubblewrap (already installed by setup script).

File Manipulation with llm-tools-patch

The llm-tools-patch plugin provides AI agents with direct file system access for reading, writing, and editing files. This enables AI to autonomously manage files during conversations.

⚠️ IMPORTANT SECURITY CONSIDERATIONS:

  • This plugin grants direct file system access to AI agents
  • Always use --ta flag to manually approve each file operation
  • Review operations carefully before approving
  • Works within the current working directory by default
  • Use --chain-limit 0 to allow unlimited consecutive tool invocations when needed

Available Operations:

  1. patch_read - Read complete file contents
  2. patch_write - Create or overwrite files
  3. patch_edit - Perform single string replacement
  4. patch_multi_edit - Execute multiple replacements sequentially
  5. patch_info - Access file metadata (size, permissions, modification time)

Usage Examples:

# Read a file (with manual approval)
llm -T Patch "Read the contents of config.yaml" --ta

# Create a new file
llm -T Patch "Create a file hello.py with a hello world program" --ta

# Edit existing file (single replacement)
llm -T Patch "In config.yaml, replace 'debug: false' with 'debug: true'" --ta

# Multiple edits in one operation
llm -T Patch "In script.sh, replace all instances of 'echo' with 'printf' and add error handling" --ta --chain-limit 0

# Get file information
llm -T Patch "Show me the file info for README.md" --ta

# Interactive mode with file access
llm chat -T Patch --ta
# > Read the package.json file
# > Update the version to 2.0.0
# > Create a new test file with basic scaffolding

Best Practices:

  • Always use --ta (tool approval) for file operations to review changes before they're applied
  • Backup important files before running multi-step edit operations
  • Use specific file paths to avoid ambiguity
  • Test with --td flag first to see what operations will be performed without executing
  • Be explicit in your prompts about what changes you want

Safety Example - Dry Run:

# See what the AI plans to do without executing
llm -T Patch "Refactor index.js to use ES6 imports" --td --ta

# The --td flag shows tool execution details
# The --ta flag requires your approval before any changes

Integration with Other Workflows:

# Combine with context tool - fix errors automatically
llm -T Patch "Read the context. The last command failed. Fix the error in the script." --ta

# Chain with code generation
llm code "python script for file backup" | tee backup.py
llm -T Patch "Add error handling to backup.py" --ta

# Use with sandboxed_shell for complete automation
llm -T Patch "Check if config.yaml exists, if not create it with default values" --ta

SQLite Database Queries

Query SQLite databases using natural language:

# Download a sample database
wget https://www.timestored.com/data/sample/chinook.db

# Query with natural language (--td shows tool calls, in this case DB queries)
llm -T 'SQLite("chinook.db")' "Count rows in the most interesting looking table" --td

# Approve database queries before execution (--ta for manual approval)
llm -T 'SQLite("chinook.db")' "Count rows in the most interesting looking table" --ta

# Interactive chat mode with database access (add --td to show DB queries)
llm chat -T 'SQLite("chinook.db")'
# > Show me the three most interesting looking tables
# > What are the top 5 best-selling artists?

The --td flag shows full details of tool executions. The --ta flag requires manual approval before each tool execution.

JSON Processing with llm-jq

Generate and execute jq programs using natural language:

# Parse JSON structures
echo '{"users": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}' | \
    llm jq 'extract names and ages'
    
# Process JSON from an API
curl -s https://api.github.com/repos/simonw/datasette/issues | \
    llm jq 'count by user.login, top 3'

# Options:
# -s/--silent: Hide the generated jq program
# -o/--output: Show only the jq program (don't execute)
# -v/--verbose: Display the AI prompt and response

Controlling Tool Execution with Chain Limits

When AI models use tools, they can call multiple tools in sequence to accomplish complex tasks. The --chain-limit (or --cl) parameter controls how many consecutive tool calls are allowed in a single prompt, preventing infinite loops while enabling multi-step reasoning.

Default Behavior:

  • Standard llm default: 5 tool calls
  • This setup's default: 15 tool calls (configured in shell wrapper)
  • Set to 0 for unlimited tool calls
# Use the default chain limit (15 in this setup)
llm "Check if docker is installed, then show all running containers"

# Allow more tool calls for complex multi-step tasks
llm --cl 30 "Analyze system, check disk space, find large files, and suggest cleanup"

# Limit tool calls to prevent excessive API usage
llm --cl 3 "Simple task with minimal tool usage"

# Unlimited tool calls (use with caution!)
llm --cl 0 "Complex task requiring many sequential operations"

# Works in chat mode too
llm chat --cl 20

When to adjust:

  • Increase (--cl 20 or higher): Complex multi-step tasks, extensive data analysis, or when you see "Chain limit reached" errors
  • Decrease (--cl 3-5): Simple tasks where you want to minimize API calls and costs
  • Unlimited (--cl 0): Only when necessary, as it can lead to excessive API usage if the model gets stuck in loops

Context System Usage

💡 Important: The context tool is built into the assistant template by default! You can ask about your terminal history naturally without typing -T context or --tool context every time.

Query your terminal history to get context-aware AI assistance. Make sure to include wording that lets the LLM know that you want it to query the history as context.

# ✅ Ask AI naturally - context tool is automatically available
llm "what was the error in my last command?"
llm chat
# > Summarize what I did in this session
# > Read the context. How do I fix the compilation error?

# ⚠️ Explicit tool invocation (useful for one-shot queries or non-assistant templates)
command llm -T context "summarize what I did in this session"

# Show last command and output directly
context

# Show last 5 commands with outputs
context 5

# Show entire session history
context all

Side-by-Side Terminal Workflow

The context -e feature enables a powerful workflow where you can query an ongoing session from a separate terminal window. This is ideal for side-by-side setups in Terminator, tmux, or any terminal multiplexer:

# Terminal 1 (left pane): Your work session
cd /opt/myproject
./build.sh
# ... working on something ...

# Get the export command
context -e

# Terminal 2 (right pane): AI assistant watching your session
# Paste the export command from Terminal 1
export SESSION_LOG_FILE="/tmp/session_logs/asciinema/2025-10-15_14-30-45-123_12345.cast"

# Now you can query what's happening in Terminal 1 in real-time
# Context tool is available automatically - just ask naturally!
llm "what did the build script just do?"
llm "were there any errors in the last command?"

# Or use chat mode for continuous assistance
llm chat
# > Read the context. What compilation errors occurred?
# > Suggest a fix for the last error shown

# Terminal 1: Keep working
make test
git commit -m "fix compilation error"

# Terminal 2: Query the updates
llm "did the tests pass?"

Use Cases:

  • Real-time debugging: Watch compilation/test output in one terminal while querying AI for solutions in another
  • Learning workflows: Execute tutorials/commands while asking AI to explain what's happening

Note: Both terminals read from the same .cast file, so the side terminal sees all commands and outputs from the work terminal as they happen.

The context system automatically captures:

  • Commands you run
  • Complete command output
  • Error messages and stack traces

This allows AI models to provide context-aware debugging and assistance based on your actual terminal activity.

RAG (Document Querying)

Query your documents, codebases, and knowledge bases using AI with llm-tools-rag. The system uses hybrid semantic+keyword search (ChromaDB vectors + BM25) for high-quality retrieval.

Quick Start:

# Add documents to a collection
llm rag add mydocs /path/to/files
llm rag add mydocs /path/to/directory/
llm rag add mydocs "*.py"              # Glob patterns supported

# Search a collection
llm rag search mydocs "how does authentication work?"

# Use RAG as a tool in conversations
llm -T 'rag("mydocs")' "Explain the authentication system"

# List all collections
llm rag list

# View collection info
llm rag info mydocs

# Rebuild BM25 index after changes
llm rag rebuild mydocs

CLI Commands:

llm rag list                          # List all RAG collections
llm rag add <collection> <path>       # Add document to collection
llm rag add <collection> <path> --refresh  # Force reindex
llm rag search <collection> <query>   # Search collection
llm rag search <collection> <query> --mode vector  # Vector-only search
llm rag search <collection> <query> --mode keyword # BM25-only search
llm rag info <collection>             # Show collection statistics
llm rag documents <collection>        # List documents in collection
llm rag sources <collection>          # Show sources from last search
llm rag rebuild <collection>          # Rebuild BM25 index
llm rag delete <collection>           # Delete collection
llm rag check-deps                    # Check document loader dependencies
llm rag repl [collection]             # Interactive REPL mode

Using RAG as a Tool:

# Simple tool usage
llm -T 'rag("mydocs")' "What does the config file contain?"

# With custom parameters
llm -T 'rag("mydocs", top_k=10, mode="hybrid")' "Find all API endpoints"

# Search modes: "hybrid" (default), "vector", "keyword"

Supported Source Types:

Source Example
Files /path/to/file.txt
Glob patterns "*.py", "**/*.md"
URL https://example.com/docs/page.html
RecursiveUrl (websites) https://example.com/docs/**
Git Repository (remote) git:https://github.com/user/repo
Git Repository (local) git:/path/to/local/repo

Supported Document Types:

The system automatically processes various file types with intelligent chunking:

  • Text files: .txt, .md, .rst, .json, .yaml, .py, .js, etc.
  • PDF files: Extracted with PyMuPDF (layout-aware)
  • DOCX files: Converted with python-docx
  • Git repositories: Use git: prefix to load source code

Adding Git Repositories:

# Remote GitHub repository
llm rag add mycode git:https://github.com/user/repo

# Local repository
llm rag add mycode git:/path/to/local/repo

💡 Why the git: prefix is required:

  • Without prefix: https://github.com/user/repo → Fetched as a web page (HTML)
  • With prefix: git:https://github.com/user/repo → Processed as a git repository (source code)

The git: prefix triggers the repository loader which:

  • Extracts source code from the repository
  • Respects .gitignore files
  • Provides clean, formatted code for the index

Search Modes:

Mode Description
hybrid Combined semantic + keyword search (default, best quality)
vector Semantic search only (good for conceptual queries)
keyword BM25 keyword search only (good for exact matches)

Tips:

  • Use descriptive collection names (e.g., aws-docs, company-policies, project-api)
  • Hybrid mode gives best results for most queries
  • Use --refresh flag to reindex documents that have changed
  • Collections are stored in ~/.config/io.datasette.llm/rag/

Image Generation (imagemage)

Generate images using Google's Gemini models (aka "Nano Banana") with the imagemage CLI. Only installed when Gemini is configured.

Available Commands:

Command Description
generate Create images from text descriptions
edit Modify existing images or compose multiple images
restore Enhance degraded photographs
icon Generate application icons in multiple sizes
pattern Create seamless textures and patterns
story Produce sequential images for visual narratives
diagram Generate technical flowcharts and diagrams

Quick Start:

# Basic image generation
imagemage generate "watercolor painting of a fox in snowy forest"

# Generate multiple variations
imagemage generate "mountain landscape" --count=3

# Edit an existing image
imagemage edit photo.png "make it black and white"

# Use cost-effective model (Gemini 2.5 Flash instead of Gemini 3 Pro)
imagemage generate "concept art" --frugal

# Specify aspect ratio (1:1, 16:9, 9:16, 4:3, 3:4, etc.)
imagemage generate "banner image" --aspect=16:9

# Generate app icons in multiple sizes
imagemage icon "minimalist cloud logo"

Configuration:

imagemage uses GEMINI_API_KEY (automatically exported by this installation script to ~/.profile).

For full documentation, see the imagemage repository.

Speech-to-Text Transcription

Transcribe audio and video files using onnx-asr with NVIDIA's Parakeet TDT model:

# Basic transcription (outputs to stdout)
transcribe recording.mp3

# Save to file
transcribe video.mp4 -o transcript.txt

# Suppress progress messages (progress goes to stderr)
transcribe meeting.m4a 2>/dev/null

Supported formats: mp3, mp4, wav, m4a, flac, ogg, webm (converted via ffmpeg)

Supported languages: 25 European languages (auto-detected): Bulgarian, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hungarian, Italian, Latvian, Lithuanian, Maltese, Polish, Portuguese, Romanian, Slovak, Slovenian, Spanish, Swedish, Russian, Ukrainian

Model: nemo-parakeet-tdt-0.6b-v3 (~600MB, auto-downloaded on first use)

For detailed documentation, see CLAUDE.md - Speech-to-Text Transcription.

Integration with Other Tools

Repository Analysis with gitingest and yek

Convert Git repositories to LLM-friendly text. Both tools serve the same purpose but with different performance characteristics:

  • gitingest: Python-based, feature-rich, good compatibility
  • yek: Rust-based, extremely fast (230x faster), parallel processing
# Using gitingest (Python-based)
gitingest https://github.com/user/repo
gitingest /path/to/local/repo

# Using yek (Rust-based, much faster)
yek https://github.com/user/repo
yek /path/to/local/repo

# Both tools output to stdout by default
yek https://github.com/user/repo > repo-context.txt

# Combine with LLM for analysis
yek https://github.com/user/repo | \
    llm "What is the main purpose of this codebase?"

# Direct analysis without saving
yek /path/to/local/repo | llm "Review architecture and suggest improvements"

# Show more parameters
gitingest --help
yek --help

Performance comparison: For large repositories with many files, yek is significantly faster due to Rust's performance and parallel processing. Choose based on your needs:

  • Use yek for large repos or when speed matters
  • Use gitingest for maximum compatibility or specific features

File Bundling with files-to-prompt

Concatenate multiple files for LLM context:

# Bundle all Python files in a directory
files-to-prompt src/*.py | llm "Review this codebase for security issues"

# Include only specific file types
files-to-prompt project/ -e py -e js | llm "What frameworks are being used?"

# Output in Claude XML format
files-to-prompt src/ -c > context.xml

# Show more parameters, e.g. for exclusion and inclusion
files-to-prompt --help

For complete documentation of parameters, see the files-to-prompt repository.

Git Log Analysis

Analyze your development history:

# Summarize recent development (last 30 days)
cd /opt/llm-linux-setup
git log --since="30 days ago" | \
    llm "In visual markdown, prepare a timeline of development during this period, including stages of work and milestones."

# Analyze commit patterns
git log --author="Your Name" --since="1 month ago" --pretty=format:"%s" | \
    llm "Categorize these commits by type (feature, fix, docs, etc.)"

Piping Workflows

Chain multiple tools together:

# Fetch, extract, and analyze
curl -s https://api.github.com/repos/simonw/llm | \
    llm jq 'extract stars, forks, and open issues' | \
    llm "Analyze the project popularity"

# Process logs
tail -n 100 /var/log/syslog | \
    llm "Identify any errors or warnings and explain them"

# Analyze command output
docker ps --format json | \
    llm jq 'count by image' | \
    llm "Which containers are running most frequently?"

LLM Functions (Optional)

Note: This is an optional feature. The installation script prepares your environment for llm-functions by installing argc and the llm-tools-llm-functions bridge plugin, but you must install llm-functions separately if you want to use it.

llm-functions is a framework that allows you to build custom LLM tools and agents using Bash, JavaScript, and Python. When installed, these tools become available to the llm command through the bridge plugin.

Installing llm-functions:

# Clone the llm-functions repository
git clone https://github.com/sigoden/llm-functions.git
cd llm-functions

# Create tools.txt to specify which tools to enable (one per line)
cat > tools.txt <<EOF
get_current_weather.sh
execute_command.sh
# execute_py_code.py  # Lines starting with # are disabled
EOF

# Build function declarations and binaries
argc build

# Verify environment is ready (checks dependencies, env vars, etc.)
argc check

Creating Custom Tools:

llm-functions uses a simple comment-based syntax to define tools:

Bash Example (tools/get_current_weather.sh):

#!/usr/bin/env bash
set -e

# @describe Get the current weather in a given location.
# @option --location! The city and optionally the state or country, e.g., "London", "San Francisco, CA".

# @env LLM_OUTPUT=/dev/stdout The output path

main() {
    curl -fsSL "https://wttr.in/$(echo "$argc_location" | sed 's/ /+/g')?format=4&M" \
    >> "$LLM_OUTPUT"
}

eval "$(argc --argc-eval "$0" "$@")"

Python Example:

See the execute_py_code.py example in the llm-functions repository. This tool uses Python's ast module to execute code and capture output, demonstrating how to define function parameters via docstrings.

JavaScript Example:

See the execute_js_code.js example in the llm-functions repository. This tool demonstrates JavaScript/Node.js code execution with output capture, using JSDoc comments to define parameters.

Tool Discovery in llm:

The llm-tools-llm-functions plugin automatically discovers tools by reading the functions.json file generated by argc build. Tools are registered with llm's function-calling system and become available to AI models.

# Use tools with llm
llm -T get_current_weather "What's the weather in Berlin?"

# In interactive mode
llm chat -T get_current_weather
# > What's the weather in Berlin?

Why llm-functions is Optional:

  • Requires manual setup and tool development
  • Best for users who need custom tool integration
  • Not everyone needs to build custom function-calling tools

Use Cases:

  • System Integration: Call system commands, APIs, or services from AI conversations
  • Custom Workflows: Build domain-specific tools for your projects
  • Automation: Create tools that interact with databases, cloud services, or local applications

For complete documentation, see the llm-functions repository.

Micro Text Editor Integration

The repository installs Micro (https://github.com/zyedidia/micro), a modern terminal-based text editor, along with llm-micro (https://github.com/ShamanicArts/llm-micro), a plugin that integrates Simon Willison's LLM CLI directly into the editor for AI-powered text generation and modification.

Architecture Overview:

  • Micro Editor: Modern, intuitive terminal editor designed as a successor to nano
  • Single Binary: No external dependencies (just libc6)
  • Lua Plugin System: Extensible via Lua-based plugins

Usage Modes:

  1. Generate Mode (no text selection):

    • Cursor positioned where you want output
    • Press Ctrl+E, type: llm write a python function to parse JSON
    • AI output inserted at cursor position
    • Context: Sends surrounding lines for better results

  2. Modify Mode (with text selection):

    • Select text to modify
    • Press Ctrl+E, type: llm fix this code
    • AI analyzes selection and replaces it with modified version
    • Context: Sends selected text plus surrounding lines

Command Syntax:

llm [options] <request>

Options:
  -t <template>, --template <template>    Use specific LLM template
  -s "<prompt>", --system "<prompt>"      Custom system prompt

Examples:
  llm write a bash function to list files
  llm -t llm-code implement binary search in python
  llm --system "you are a python expert" optimize this loop
  llm fix the syntax error in this code

Template Commands:

llm_template <name>              # Open/edit template YAML
llm_template_default <name>      # Set default template
llm_template_default --clear     # Remove default template
llm_template_default --show      # Show current default

Configuration (~/.config/micro/settings.json):

{
    "llm.default_template": "assistant",
    "llm.context_lines": 100
}

Settings:

  • llm.default_template (string, default: ""): Default template for LLM operations
  • llm.context_lines (number, default: 100): Lines of context before/after cursor; 0 to disable

Automatic Features:

  • Markdown Extraction: Automatically appends -x flag to extract text from code blocks
  • Progress Messages: Shows status in Micro's infobar during generation
  • Context Awareness: Sends surrounding code for better AI understanding

Workflow Examples:

# Launch Micro
micro myfile.py

# Generate new code (no selection)
# Position cursor, press Ctrl+E
llm write a function to calculate fibonacci

# Modify existing code (with selection)
# Select code block, press Ctrl+E
llm add error handling to this function

# Use specific template
llm -t llm-code implement quicksort in python

# Custom system prompt
llm -s "you are a security expert" review this code for vulnerabilities

Tips:

  • Set llm.default_template to your most-used template for faster workflow
  • Use -t llm-code template for clean, executable code without explanations
  • Adjust llm.context_lines based on your needs (more context = better understanding, but slower)
  • View plugin logs: Press Ctrl+E, type log to see debug output

Terminator Assistant

The repository includes llm-assistant, a TmuxAI-inspired terminal AI assistant for Terminator terminal emulator that provides an interactive AI pair programming experience.

Key Features:

  • Automatic Exec terminal: Auto-creates split terminal for command execution
  • Smart context: Captures all terminals except its own (self-aware)
  • Watch mode: Proactive monitoring with user-defined goals
  • Command execution: AI suggests commands, you approve, they run in Exec terminal
  • Streaming responses: Rich markdown rendering with streaming output

Quick Start:

# Launch assistant in any Terminator terminal
llm assistant

# Launch with specific model
llm assistant azure/gpt-4.1

# Direct invocation also works
llm-assistant

Workflow:

  1. Run llm assistant in any Terminator terminal
  2. Script auto-creates Exec terminal via D-Bus hsplit
  3. Type messages in Chat terminal (where script runs)
  4. AI responds with streaming markdown
  5. If AI suggests commands (<EXECUTE> tags), prompted: "Execute? [y/n/e]"
  6. Approved commands run in Exec terminal
  7. Command output captured for next AI iteration

Slash Commands:

Command Description
/help Show available commands
/clear Clear conversation history
/reset Full reset: clear history and remove squash summaries
/model [name] Switch AI model or list available models
/info Show session info (conversation ID, context size, model)
/watch <goal> Enable watch mode (e.g., /watch detect security issues)
/watch off Disable watch mode
/squash Manually compress conversation context
/quit Exit assistant

Input Modes:

  • !multi - Enter multi-line input mode (finish with !end)
  • !fragment <name> - Attach an llm fragment to the conversation

Watch Mode Example:

you> /watch detect inefficient commands
Watch mode enabled: monitoring all terminals
# AI now monitors all terminals and provides proactive suggestions

Requirements:

  • Terminator terminal emulator
  • Plugin enabled: Terminator Preferences -> Plugins -> Check "TerminatorAssistant"

For detailed documentation, see integration/CLAUDE.md.

Claude Code Router

Claude Code Router (CCR) is an intelligent proxy that routes Claude Code requests to different LLM providers based on task type. It enables multi-provider setups that regular Claude Code doesn't support.

Key Features:

  • Dual-provider support: Azure OpenAI for main tasks + Gemini for web search
  • Gemini-only mode: All tasks routed to Google Gemini
  • Task-aware routing: Different models for different task types
  • Automatic configuration: Detects available providers and configures accordingly

Quick Start:

# Launch Claude Code through the router
routed-claude

Provider Configurations:

Mode Primary Provider Web Search Use Case
Dual-Provider Azure OpenAI Gemini Enterprise with Azure + free Gemini
Gemini-Only Gemini Gemini Free tier or Gemini preference

Routing Options:

Route Type Purpose
default Main code generation tasks
background Analysis with cost optimization
think Complex reasoning (uses best model)
longContext Large file/project handling
webSearch Web-dependent research

Configuration:

  • Config file: ~/.claude-code-router/config.json
  • Auto-generated based on available provider keys
  • User modifications preserved via checksum tracking

Note: CCR can use both providers simultaneously in dual-provider mode (Azure + Gemini).

For technical details, see CLAUDE.md.

Managing Models

List Available Models

# List all models (shows Azure, Gemini, and other configured models)
llm models

# Find default model
llm models | grep -i default

# List Azure models
llm models | grep azure

# List Gemini models
llm models | grep gemini

# Get detailed Gemini model info
llm gemini models

Set Default Model

# Set default model for all commands
llm models default azure/gpt-4.1-mini

# Alternative: using environment variable
export LLM_MODEL=azure/gpt-4.1
llm "Your prompt"  # Uses gpt-4.1

Use Specific Models

# Override default with -m flag
llm "Ten names for cheesecakes" -m azure/gpt-4.1-mini

# Use different models for different tasks
llm -m azure/gpt-4.1 "Enterprise compliance analysis"
llm -m gemini-2.5-flash "Personal coding question"
llm -m gemini-2.5-flash "Describe this image" -a photo.jpg

Azure OpenAI Models

The following Azure models are configured (examples):

  • azure/gpt-4.1 - GPT-4.1 (most capable)
  • azure/gpt-4.1-mini - GPT-4.1 Mini (balanced, default)
  • azure/gpt-4.1-nano - GPT-4.1 Nano (fast, cost-effective)
  • azure/o4-mini - O4 Mini (advanced reasoning)
  • azure/gpt-5-mini, azure/gpt-5-nano, azure/gpt-5.1 - GPT-5 models

Default Model Recommendation:

This setup uses azure/gpt-4.1-mini as the default for its balance of performance and cost-effectiveness. For more complex tasks requiring deeper reasoning (such as extensive code analysis, multi-step problem solving, or nuanced decision making), switch to azure/gpt-4.1:

# Switch to gpt-4.1 for complex tasks
llm models default azure/gpt-4.1

# Or use it for a single query with -m flag
llm -m azure/gpt-4.1 "Complex analysis task..."

Note: Model IDs shown above are examples from a specific Azure deployment. Your available models depend on your Azure Foundry configuration. Use llm models to see your configured models.

Model-Specific Parameters

Different model providers support unique parameters beyond the standard temperature and max_tokens settings. Use the -o (options) flag to pass provider-specific parameters.

Gemini and Vertex AI Models

Google's Gemini models (via llm-gemini and llm-vertex plugins) support advanced features like code execution:

# Enable code execution for computational tasks
command llm -m gemini-2.5-flash -o code_execution 1 \
  "write and execute python to calculate fibonacci sequence up to n=20"

# Use Vertex AI with code execution
command llm -m vertex/gemini-2.5-flash -o code_execution 1 \
  "write and execute python to generate a 80x40 ascii art fractal"

# Combine with other options
command llm -m gemini-2.5-flash \
  -o code_execution 1 \
  -o temperature 0.7 \
  "solve this math problem step by step with code"

Code Execution Feature: When enabled, Gemini models can write Python code, execute it in a secure sandbox, see the results, and incorporate the output into their response. This is particularly powerful for:

  • Mathematical calculations
  • Data analysis and visualization
  • Algorithm implementation and testing
  • Generating dynamic content (ASCII art, graphs, etc.)

Reasoning Models (o-series)

OpenAI's reasoning models support effort control:

# High reasoning effort for complex problems
command llm -m openai/o4-mini \
  -o reasoning_effort high \
  "design a distributed caching system with these requirements..."

# Medium effort for balanced performance
command llm -m azure/o4-mini \
  -o reasoning_effort medium \
  "analyze this algorithm's time complexity"

# Low effort for simpler reasoning tasks
command llm -m openai/o4-mini \
  -o reasoning_effort low \
  "explain this code pattern"

Common Model Options

Standard options supported across most models:

# Control randomness (0.0 = deterministic, 2.0 = very creative)
llm -m gemini-2.5-flash -o temperature 0.9 "creative story prompt"

# Limit output length
llm -m azure/gpt-4.1 -o max_tokens 500 "brief summary needed"

# Combine multiple options
llm -m claude-sonnet-4.5 \
  -o temperature 0.3 \
  -o max_tokens 2000 \
  "technical documentation request"

Temperature Range Note: Gemini models support temperature values from 0 to 2.0, while most other models use 0 to 1.0. Check your model's documentation for valid ranges.

For complete parameter documentation:

Managing API Keys

Configure Azure OpenAI Key:

# Set Azure key interactively
llm keys set azure

# View configured keys
llm keys

# View key storage path
llm keys path

Configure Gemini Key:

# Set Gemini key interactively
llm keys set gemini

# Verify Gemini key is working
llm -m gemini-2.5-flash "test prompt"

Get API Keys:

Understanding the Shell Integration

The installation adds a smart wrapper function around the llm command that automatically applies templates based on context. This means you rarely need to specify -t llm explicitly!

How Automatic Templates Work

✅ When the assistant template is AUTO-APPLIED:

  • llm "Your question" → Uses assistant template automatically
  • llm chat → Uses assistant template automatically
  • Any prompt command without explicit template specification

⚠️ When templates are NOT auto-applied:

  • When continuing a conversation: llm chat -c, llm -c "follow-up"
  • When specifying a custom template: llm -t fabric:summarize
  • When using a custom system prompt: llm -s "You are..."
  • For management commands: llm models, llm keys, llm plugins, etc.
  • For specialized subcommands: llm cmd, llm jq, llm cmdcomp, etc.

Bypassing the Shell Wrapper

If you need to execute the original llm command without the shell wrapper function (for debugging, testing, or to avoid automatic template application), use the command builtin:

# Bypasses the wrapper (no automatic template)
command llm "Your question"

# Useful for debugging or when you want exact control
command llm -t llm "Your question"  # You must specify -t explicitly

When to use command llm:

  • Testing without automatic template modifications
  • Scripts that need exact llm behavior without wrapper modifications
  • When you want complete manual control over all parameters

When to Use -t

You ONLY need -t when you want a DIFFERENT template:

# ❌ Unnecessary (assistant is already default)
llm -t llm "What is Docker?"

# ✅ Correct (just omit -t)
llm "What is Docker?"

# ✅ Use -t for non-default templates
llm -t fabric:summarize < report.txt
llm -t fabric:analyze_threat_report -a report.pdf

Key Benefits

What does the assistant template do? See the llm.yaml source - it configures the AI with:

  • Security/IT/Linux expertise (20 years experience)
  • Cybersecurity focus (ethical hacking, forensics, incident response)
  • Kali Linux/Ubuntu/Debian environment awareness
  • Integrated context tool for reading terminal history (automatically available!)
  • Integrated sandboxed_shell tool for safe command execution (automatically available!)

Context Tool Integration

The assistant template includes the context and sandboxed_shell tools by default, which means AI models can automatically read your terminal history and execute shell commands safely without you needing to explicitly specify --tool context or -T sandboxed_shell every time!

✅ When these tools are automatically available:

# Just ask naturally - the AI can use the context tool
llm "what was the error in my last command?"

# Or ask the AI to run commands via sandboxed_shell
llm "check if docker is installed and show version"

llm chat
# > Read the context. What did I just run?
# > Can you explain the output from my last command?
# > List the files in /root

⚠️ When you need to use tools explicitly:

# When using a different template
llm -t fabric:summarize --tool context "what happened?"
llm -t fabric:summarize -T sandboxed_shell "check docker"

# When bypassing the shell wrapper
command llm --tool context "what went wrong?"
command llm -T sandboxed_shell "run this safely"

Session Recording & Context System

This setup includes an automatic terminal session recording system that captures your command history and allows AI models to query it for context-aware assistance.

How It Works

  1. Automatic Recording: Every interactive shell session is automatically recorded using asciinema

    • Recording starts transparently when you open a terminal
    • Each tmux/screen pane gets its own independent recording

  2. Context Extraction: The context command parses asciinema recordings to show command history

    • Shows commands with their complete output
    • Supports showing last N commands or entire session

  3. AI Integration: The llm-tools-context plugin exposes terminal history as a tool

    • The context tool is built into the assistant template by default
    • AI models can automatically query your recent command history during conversations
    • Just ask naturally: llm "what was the error?" - no need for --tool context!
    • Explicit --tool context is only needed for non-assistant templates or continuations

Storage Configuration

On first installation, you'll be prompted to choose where session recordings are stored:

  • Temporary (default): /tmp/session_logs/asciinema/ - Cleared on reboot, saves disk space
  • Permanent: ~/session_logs/asciinema/ - Survives reboots, useful for long-term history

You can change this later by editing the SESSION_LOG_DIR export in your .bashrc or .zshrc.

Suppressing Session Start Messages:

To hide the "Session is logged for 'context'..." message on shell startup:

# Add to your .bashrc or .zshrc before the integration source line
export SESSION_LOG_SILENT=1

Useful for cleaner shell startup or automated environments.

Understanding Azure OpenAI Setup

This installation can configure either Azure OpenAI (Azure Foundry) or Google Gemini as your primary provider. On first run, you'll be asked which provider you want to use.

If you choose Azure OpenAI (default choice for enterprise/workplace use), the setup differs from standard OpenAI API integration.

Architecture Overview

Key Differences from Standard OpenAI:

  • Uses Azure-hosted OpenAI models (not direct OpenAI API)
  • Model IDs require azure/ prefix (e.g., azure/gpt-4.1-mini, azure/o4-mini)
  • Requires separate API key (azure not openai)
  • API base URL points to your Azure resource (e.g., https://your-resource.openai.azure.com)

Azure Configuration Files

LLM Configuration:

  • Location: ~/.config/io.datasette.llm/extra-openai-models.yaml
  • Purpose: Defines Azure-hosted models for llm CLI tool
  • Format: YAML file with model definitions

Example structure:

- model_id: azure/gpt-4.1-mini
  model_name: gpt-4.1-mini
  api_base: https://your-resource.openai.azure.com
  api_key_name: azure

Azure-Specific Limitations

⚠️ PDF Attachments Not Supported: Azure OpenAI models in this setup support image attachments but NOT PDF attachments. When trying to use PDFs with the -a/--attachment parameter, you will receive this error:

Error you'll see:

Error code: 400 - {'error': {'message': "Invalid Value: 'file'.
This model does not support file content types.", 'type': 'invalid_request_error'}}

Workarounds for PDF attachments:

  1. For text extraction from PDFs: Use the pdf: fragment

    llm -f pdf:document.pdf "summarize the text"

  2. For PDF visual analysis: Use non-Azure models

    llm -m gpt-4o "analyze this PDF" -a document.pdf
llm -m gemini-2.5-flash "describe" -a poster.pdf
llm -m claude-sonnet-4.5 "analyze" -a document.pdf

Why Azure OpenAI?

When Azure is the right choice:

  • Enterprise/workplace requirements - Compliance, SLAs, data residency
  • Organizational policies - Centralized billing, governance
  • Private deployments - Models hosted in your Azure subscription

When to consider alternatives:

  • Personal/hobbyist use - Free tiers available elsewhere (see Gemini section below)
  • Attachment support needed - Standard APIs support multimodal better
  • No Azure subscription - Direct API access simpler

Alternative: Gemini for Private Use

For personal projects, learning, and hobbyist use, Google's Gemini 2.5 Flash offers exceptional value with a generous free tier and competitive performance.

Choosing between providers:

  • Azure OpenAI: Enterprise/workplace environments, compliance requirements
  • Gemini: Personal projects, free tier, hobbyist use

Get your API key:

  • Visit Google AI Studio
  • Sign up (free, no credit card required)
  • Generate an API key from the dashboard

Switching Providers

To switch from Azure to Gemini or vice versa:

# Switch to Gemini
./install-llm-tools.sh --gemini

# Switch to Azure
./install-llm-tools.sh --azure

The script will reconfigure the selected provider.

Temperature Note: Gemini supports temperature values from 0 to 2.0, while most models use 0 to 1.0. Be mindful when setting temperature values.

Configuration

Configuration Files

  • ~/.config/io.datasette.llm/ - LLM configuration directory

    • extra-openai-models.yaml - Azure OpenAI model definitions
    • templates/llm.yaml - Custom assistant template with security/IT expertise (cybersecurity focus)
    • templates/llm-code.yaml - Code-only generation template (no markdown, no explanations)
    • default_model.txt - Currently selected default model
    • API keys stored securely via llm's key management

  • ~/.config/llm-tools/ - Additional tool configuration

    • asciinema-commit - Tracks asciinema version for update detection

  • $SESSION_LOG_DIR/ - Session recording storage

    • Default: /tmp/session_logs/asciinema/ (temporary) or ~/session_logs/asciinema/ (permanent)
    • Contains .cast files with terminal session recordings
    • Configured via SESSION_LOG_DIR environment variable in your shell RC file

  • ~/.config/io.datasette.llm/rag/ - RAG collections (llm-tools-rag)

    • Contains ChromaDB vector databases and BM25 indices

Shell Integration Files

Located in the integration/ subdirectory:

These are automatically sourced from your .bashrc or .zshrc.

Troubleshooting

Update fails

"fatal: Not possible to fast-forward, aborting"

This error occurs when your local git branch has diverged from the remote (both have conflicting changes). This typically happens if you made local edits to files that were also updated remotely.

Solutions:

# Option 1: Discard local changes and match remote (recommended)
cd /opt/llm-linux-setup
git reset --hard origin/main
./install-llm-tools.sh

# Option 2: Try to reapply your local commits on top of remote changes
git pull --rebase

# Option 3: Nuclear option - delete and re-clone
sudo rm -rf /opt/llm-linux-setup
sudo git clone https://github.com/c0ffee0wl/llm-linux-setup.git /opt/llm-linux-setup
sudo chown -R $(whoami):$(whoami) /opt/llm-linux-setup
cd /opt/llm-linux-setup
./install-llm-tools.sh

Command completion not working

For Ctrl+N (AI completion):

  1. Restart your shell or source your profile:

    source ~/.bashrc  # or ~/.zshrc

  2. Verify llm is in PATH:

    which llm

  3. Test llm command completion:

    llm cmdcomp "list files"

For Tab completion (Zsh only):

  1. Verify you're using Zsh: echo $SHELL (should show /bin/zsh or similar)

  2. Clear completion cache and restart shell:

    rm -f ~/.zcompdump*
exec zsh

  3. Verify the plugin is in fpath:

    echo $fpath | grep llm-zsh-plugin

  4. Test tab completion:

    llm <TAB>  # Should show: chat, code, rag, models, etc.

Azure API errors

  1. Verify API key is set:

    llm keys get azure

  2. Check model configuration:

    cat ~/.config/io.datasette.llm/extra-openai-models.yaml

  3. Update the API base URL in the YAML file if needed

Rust version issues

Problem: cargo install fails with errors about minimum Rust version

Solution: The script automatically detects and offers to upgrade Rust to 1.85+ via rustup. If you declined during installation:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

Check Rust version:

rustc --version

Node.js version issues

Problem: npm or node commands fail, or Claude Code won't install

Solution: The script requires Node.js 20+. If you have an older version:

# Install nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
source ~/.bashrc  # or ~/.zshrc

# Install Node 22
nvm install 22
nvm use 22
nvm alias default 22

Session recording not working

Problem: context command shows "No asciinema session recording found"

Solutions:

  1. Verify asciinema is installed and in PATH:

    which asciinema

  2. Check shell integration is loaded:

    grep -r "llm-integration" ~/.bashrc ~/.zshrc

  3. Restart your shell or re-source your RC file:

    source ~/.bashrc  # or ~/.zshrc

  4. Check if recording is active (should see asciinema process):

    ps aux | grep asciinema

Context shows wrong session

Problem: context command shows old or wrong session history

Solutions:

  1. Check current session file:

    echo $SESSION_LOG_FILE

  2. Manually set session file if needed:

    export SESSION_LOG_FILE="/path/to/your/session.cast"

  3. Get correct export command:

    context -e

tmux panes not recording independently

Problem: New tmux panes don't get their own recordings

Solution: Check for pane-specific environment markers:

env | grep IN_ASCIINEMA_SESSION

You should see markers like IN_ASCIINEMA_SESSION_tmux_0=1 for each pane. If not, re-source your shell RC file in the new pane:

source ~/.bashrc  # or ~/.zshrc

Support

For issues, questions, or suggestions:

Related Projects

Credits

Core Tools & Frameworks

  • Simon Willison - Original llm CLI tool and plugins (llm-gemini, llm-anthropic, llm-openrouter, llm-jq, llm-tools-sqlite, llm-tools-quickjs, llm-fragments-github, llm-cmd)
  • c0ffee0wl - llm fork with markdown markup enhancements
  • sigoden - argc Bash CLI framework and llm-functions framework
  • Anthropic - Claude Code agentic coding CLI
  • Astral - uv Python package manager
  • Rust Foundation - Rust programming language and Cargo
  • Node.js Foundation - Node.js JavaScript runtime

LLM Plugins & Extensions

Additional Tools

License

This installation script is provided as-is. Individual tools have their own licenses:

  • llm: Apache 2.0
  • See individual tool repositories for details

Contributing

To modify or extend this installation, see CLAUDE.md for detailed architecture documentation.

Key files to understand:

Development workflow:

  1. Read CLAUDE.md to understand architecture
  2. Edit the scripts in the repository
  3. Test your changes
  4. Commit and push to git
  5. Changes pulled automatically on next run

About

No description, website, or topics provided.

Resources

Readme

License

GPL-3.0 license
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 2

  •  
  •  

Languages