gptme

Maintains stateful conversations across multiple LLM providers (OpenAI, Anthropic, Ollama, etc.) with automatic provider switching and conversation persistence to disk. Implements a provider abstraction layer that normalizes API differences and handles token counting, streaming responses, and error recovery across heterogeneous backends. Conversations are serialized to JSON with full message history, allowing resumption across CLI sessions.

Executes arbitrary code (Python, shell, etc.) in a sandboxed subprocess environment and feeds execution errors, stdout, and stderr directly back to the LLM for automatic correction. The agent iteratively refines code based on runtime failures without user intervention, implementing a feedback loop where the LLM reads error messages and modifies code accordingly. Supports multiple execution contexts (Python REPL, bash shell) with environment isolation.

Abstracts streaming response handling across multiple LLM providers (OpenAI, Anthropic, Ollama, etc.) with a unified interface that normalizes differences in streaming protocols, error handling, and response formats. Implements automatic fallback to alternative providers if the primary provider fails or is unavailable, with transparent error recovery and retry logic. Supports both server-sent events (SSE) and chunked HTTP responses.

Allows the LLM to read, write, create, and modify files on the user's filesystem through a tool interface that interprets natural language file operations. The agent can create new files, append to existing ones, read file contents for context, and delete files based on conversational intent. File operations are logged and reversible through conversation history, enabling the user to understand what changes were made and why.

Enables the LLM to fetch and parse web content by issuing HTTP requests to URLs, extracting text/HTML, and feeding results back into the conversation context. The agent can browse websites, retrieve documentation, scrape data, and analyze web content without user manual copy-paste. Implements a web tool that handles redirects, timeouts, and content parsing (HTML to text extraction) transparently.

Accepts image files (PNG, JPEG, etc.) as input and sends them to vision-capable LLM providers (OpenAI GPT-4V, Claude 3 Vision, etc.) for analysis, OCR, and visual reasoning. The agent can describe images, extract text from screenshots, analyze diagrams, and answer questions about visual content. Supports both local file paths and inline image encoding for API transmission.

Implements a function calling system where the LLM can invoke predefined tools (code execution, file operations, web browsing, vision, etc.) by generating structured function calls that are parsed and routed to the appropriate handler. Uses a schema registry to define tool signatures, validate inputs, and execute handlers, with automatic error handling and result feedback to the LLM. Supports both native tool definitions and integration with provider-specific function calling APIs (OpenAI functions, Anthropic tools).

Manages conversation history with automatic token counting and context window optimization. As conversations grow, the system intelligently truncates or summarizes older messages to fit within the LLM's token limits, preserving recent context and important information. Implements a token budget system that reserves space for the response and calculates how much history can fit, with configurable truncation strategies (sliding window, summarization, etc.).

Provides a terminal-based user interface that streams LLM responses in real-time as they are generated, with syntax highlighting for code blocks, formatted output for structured data, and interactive prompting for user input. Implements a message loop that handles user input, sends requests to the LLM, streams responses, and displays tool execution results inline. Supports multi-line input, command history, and readline-style editing.

Persists conversations to disk in a structured format (JSON or similar) that captures all messages, tool calls, execution results, and metadata. Enables users to save conversations, close the CLI, and resume later with full context recovery. Implements a serialization format that preserves the exact conversation state, including provider configuration, token usage, and execution history, allowing seamless resumption without re-running tools or re-fetching data.

Supports multi-turn conversations where the LLM can reason through complex problems step-by-step, with explicit prompting for chain-of-thought reasoning. The agent can break down problems into sub-tasks, execute tools to gather information, and iteratively refine solutions based on results. Implements a conversation loop that encourages the LLM to explain its reasoning and ask clarifying questions.