GitHub Actions Integration

Real-world automation using LLMProc in GitHub workflows:

@llmproc /resolve

Automatically resolve merge conflicts

Intelligently merges conflicting changes when possible

@llmproc /ask

Answer questions on issues/PRs

Get AI-powered answers with full context awareness

@llmproc /code

Implement features from comments

Turn feature requests into working code automatically

Quick Setup

# Install workflows automatically in your repository root:

uvx --from llmproc llmproc-install-actions

The installer will download workflow files and provide step-by-step instructions.

Required secrets in repository settings:

• ANTHROPIC_API_KEY - API key for Claude
• LLMPROC_WRITE_TOKEN - GitHub PAT with write permissions (contents, pull-requests)

View workflow files and examples

Production-Ready Features

Zero Token Overhead

No built-in system prompt overhead. Control every token sent to the LLM.

Type-Safe Python SDK

Configuration-Driven

Define LLM programs in YAML/TOML with complete customization control.

Flexible Tool System

Built-in tools, MCP protocol support, tool aliases, and access control.

Production Features

Prompt caching, automatic retries, callbacks, and robust error handling.

Multi-Provider Support

Native support for Anthropic Claude, OpenAI, and Google Gemini models.

Ready to Build with LLMProc?

Production-ready LLM runtime. Complete control. Zero overhead.

Install Now View on GitHub

Install via pip:

Basic installation (Anthropic support)

pip install llmproc

Run without installing (requires uv)

uvx llmproc --help

Token Overhead

100%

Open Source

∞

Customization

Code Examples

Basic YAML Configuration

model:
  name: "claude-3-5-haiku-20241022"
  provider: "anthropic"

prompt:
  system_prompt: |
    You are Claude, an AI assistant with advanced reasoning capabilities.

parameters:
  max_tokens: 4096
  temperature: 0.7

tools:
  builtin: ["read_file", "calculator", "list_dir"]

env_info:
  variables: ["working_directory", "platform", "date"]

Advanced TOML Configuration

# TOML configuration with advanced features
[model]
name = "claude-3-7-sonnet-20250219"
provider = "anthropic"

[parameters]
max_tokens = 8192

# Enable thinking capability
[parameters.thinking]
type = "enabled"
budget_tokens = 4000

# Tool aliases for easier use
[tools]
builtin = [
    {name = "read_file", alias = "read"},
    {name = "calculator", alias = "calc"},
]

Quick Start

import asyncio
from llmproc import LLMProgram

def multiply(a: float, b: float) -> dict:
    """Multiply two numbers and return the result."""
    return {"result": a * b}

async def main():
    program = LLMProgram(
        model_name="claude-3-5-haiku-20241022",
        provider="anthropic",
        system_prompt="You're a helpful assistant.",
        parameters={"max_tokens": 1024},
        tools=[multiply],
    )
    process = await program.start()
    await process.run("Can you multiply 3.14159 by 2.71828?")
    print(process.get_last_message())

asyncio.run(main())

Custom Tools

from llmproc import LLMProgram, register_tool

# Register tools with automatic schema generation
@register_tool(name="calculator")
def calculate(expression: str) -> dict:
    """Calculate arithmetic expressions."""
    result = eval(expression, {"__builtins__": {}})
    return {"result": result}

program = (
    LLMProgram(
        model_name="claude-3-7-sonnet-20250219",
        provider="anthropic",
        parameters={"max_tokens": 8192}
    )
    .register_tools([calculate])
    .set_tool_aliases({"calc": "calculator"})
    .enable_token_efficient_tools()
)

From Config File

# Load from YAML/TOML configuration
program = LLMProgram.from_file("llmproc-config.yaml")

# Configure advanced features
program = program.configure_thinking(budget_tokens=4096)
program = program.configure_file_descriptor(
    enabled=True,
    max_direct_output_chars=8000
)

process = await program.start()
result = await process.run("Analyze this codebase")

LLMProc

Quick Install