gptme

https://gptme.org/docs
Admin
gptme is an ecosystem of tools for interacting with AI agents equipped with powerful local tools,...
Tokens:81,029
Snippets:431
Trust Score:6.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### GPTME Getting Started Guide

Source: https://gptme.org/docs/index

A guide for new users to get started with gptme, covering installation and initial setup.

```APIDOC
Getting Started:
  A guide for new users to get started with gptme, covering installation and initial setup.
```

--------------------------------

### gptme Quick Examples

Source: https://gptme.org/docs/getting-started

Demonstrates various use cases for gptme, including code generation, file analysis, development workflows, and resuming conversations. These examples showcase the versatility of the tool.

```bash
# Create applications and games
gptme'write a web app to particles.html which shows off an impressive and colorful particle effect using three.js'
gptme'create a performant n-body simulation in rust'

# Work with files and code
gptme'summarize this''refactor this''what do you see?'# vision

# Development workflows
git|'commit'
maketest|'fix the failing tests'
gptme'implement this'# Chain multiple tasks
gptme'make a change''test it''commit it'

# Resume conversations
gptme
```

--------------------------------

### Install gptme using pipx

Source: https://gptme.org/docs/getting-started

Instructions for installing gptme using pipx, a tool for installing and running Python applications in isolated environments. It also provides a fallback for installing pipx itself if it's not already present.

```bash
pipx install gptme
```

```bash
pip install --user pipx
pipx ensurepath
```

--------------------------------

### Example gptme Command

Source: https://gptme.org/docs/contributing

A basic example of running the gptme command after setup.

```bash
'hello'
```

--------------------------------

### Install and Start gptme Server

Source: https://gptme.org/docs/llms-full

Installs the gptme server with necessary extras and starts the gptme server process. This enables browser-based interactions with gptme agents.

```bash
pipx install 'gptme[server]'
gptme-server
```

--------------------------------

### Start gptme interactive chat

Source: https://gptme.org/docs/getting-started

Command to initiate an interactive chat session with the gptme AI assistant. This command starts the core functionality of the tool.

```bash
gptme
```

--------------------------------

### Install GPTMe and Dependencies

Source: https://gptme.org/docs/llms-full

Installs the GPTMe package and other essential tools like uv and pre-commit using pipx for isolated environments. This ensures a clean and manageable setup for the project.

```bash
# Install required dependencies
pipx install gptme   # or `pipx install -e ./gptme` to install from local source
pipx install uv
pipx install pre-commit
```

--------------------------------

### GPTME Installation and Build

Source: https://gptme.org/docs/llms-full

Instructions for cloning the gptme repository, installing Poetry, activating the virtual environment, and building the project. It also covers installing in editable mode using pipx.

```bash
# checkout the code and navigate to the root of the project
git clone https://github.com/gptme/gptme.git
cd gptme

# install poetry (if not installed)
pipx install poetry

# activate the virtualenv
poetry shell

# build the project
make build

You can now start ``gptme`` from your development environment using the regular commands.

You can also install it in editable mode with ``pipx`` using ``pipx install -e .`` which will let you use your development version of gptme regardless of venv.
```

--------------------------------

### Install and Build gptme

Source: https://gptme.org/docs/contributing

Steps to clone the repository, install dependencies using Poetry, and build the project. It also explains how to install gptme in editable mode for development.

```bash
# checkout the code and navigate to the root of the project
git cd
# install poetry (if not installed)
pipx
# activate the virtualenv
poetry
# build the project
make
```

```bash
pipx install -e .
```

--------------------------------

### GPTMe Command Line Usage Examples

Source: https://gptme.org/docs/usage

Illustrates various command-line operations for GPTMe, including making improvements to files, chaining prompts for complex tasks, skipping confirmation prompts, and running in non-interactive mode for automation.

```bash
'make improvements to life.py so that dead cells fade out over time'

```

```bash
'create a project''add tests''commit changes'

```

```bash
'create a snake game using curses in snake.py, dont run it'

```

```bash
'create a snake game using curses in snake.py, dont run it''-''make the snake green and the apple red'

```

--------------------------------

### Local LLM Setup with Ollama

Source: https://gptme.org/docs/llms-full

Instructions for setting up and using local LLM models with GPTME via Ollama. This involves pulling a model, starting the Ollama serve, and configuring the OpenAI base URL.

```sh
ollama pull llama3.2:1b
ollama serve
OPENAI_BASE_URL="http://127.0.0.1:11434/v1" gptme 'hello' -m local/llama3.2:1b
```

--------------------------------

### GPTME Contributing Guide

Source: https://gptme.org/docs/index

Information for developers interested in contributing to the gptme project, including setup and contribution guidelines.

```APIDOC
Contributing:
  Information for developers interested in contributing to the gptme project, including setup and contribution guidelines.
```

--------------------------------

### Install GPTMe Server Extras

Source: https://gptme.org/docs/server

Installs the necessary components for GPTMe's server capabilities, enabling web-based interactions.

```bash
'gptme[server]'
```

--------------------------------

### Run gptme-server Executable

Source: https://gptme.org/docs/building

Examples of how to run the built gptme-server executable and how to display its help information.

```bash
# Run the server
./dist/gptme-server0.0.0.05700

# Show help
./dist/gptme-server
```

--------------------------------

### Docker Setup for Computer Use Interface

Source: https://gptme.org/docs/llms-full

Instructions to clone the gptme repository, build the Docker image for the computer use interface, and run the container. This setup allows for an interactive desktop environment integrated with the chat interface.

```bash
git clone https://github.com/gptme/gptme.git
cd gptme

make build-docker-computer
docker run -v ~/.config/gptme:/home/computeruse/.config/gptme -p 6080:6080 -p 8080:8080 gptme-computer:latest
```

--------------------------------

### GPTME Model Selection Examples

Source: https://gptme.org/docs/llms-full

Demonstrates how to select different LLM providers and models using the gptme CLI. Includes examples for OpenAI, Anthropic, OpenRouter, Deepseek, Gemini, Groq, Xai, and local models.

```sh
gptme --model openai/gpt-4o "hello"
gptme --model anthropic "hello"
gptme --model openrouter/meta-llama/llama-3.1-70b-instruct "hello"
gptme --model deepseek/deepseek-reasoner "hello"
gptme --model gemini/gemini-1.5-flash-latest "hello"
gptme --model groq/llama-3.3-70b-versatile "hello"
gptme --model xai/grok-beta "hello"
gptme --model local/llama3.2:1b "hello"
```

--------------------------------

### SQLite MCP Server Configuration

Source: https://gptme.org/docs/mcp

Example configuration for running an MCP server that provides SQLite database interaction and business intelligence capabilities. It specifies the command to start the server and the path to the SQLite database file.

```toml
[[mcp.servers]]
name="sqlite"
enabled=true
command="uvx"
args=[
"mcp-server-sqlite",
"--db-path",
"/path/to/sqlitemcp-store.sqlite"
]

```

--------------------------------

### GPTME Telemetry Setup

Source: https://gptme.org/docs/llms-full

Steps to enable and configure OpenTelemetry for gptme, including installing telemetry dependencies, running Jaeger and Prometheus Docker containers, setting environment variables, and viewing telemetry data.

```bash
# Install telemetry dependencies:
poetry install -E telemetry

# Run Jaeger for trace visualization:
docker run --rm --name jaeger \
          -p 16686:16686 \
          -p 4317:4317 \
          -p 4318:4318 \
          -p 5778:5778 \
          -p 9411:9411 \
          cr.jaegertracing.io/jaegertracing/jaeger:latest

# Run Prometheus for metrics collection:
docker run --rm --name prometheus \
          -p 9090:9090 \
          -v $(pwd)/scripts/prometheus.yml:/prometheus/prometheus.yml \
          prom/prometheus --web.enable-otlp-receiver

# Set the telemetry environment variables:
export GPTME_TELEMETRY_ENABLED=true
export OTLP_ENDPOINT=http://localhost:4317
export PROMETHEUS_ADDR=0.0.0.0  # optional (default: localhost, use 0.0.0.0 for Docker access)
export PROMETHEUS_PORT=8000

# Run gptme:
poetry run gptme 'hello'
# or gptme-server
poetry run gptme-server

# View data:
# - Traces: Jaeger UI at http://localhost:16686
# - Metrics: Prometheus UI at http://localhost:9090
# - Raw metrics: Direct metrics endpoint at http://localhost:8000/metrics

Once enabled, gptme will automatically:

- Trace function execution times
- Record token processing metrics
- Monitor request durations
```

--------------------------------

### GPTME Examples and Demos

Source: https://gptme.org/docs/index

Provides practical examples and demonstrations of gptme's capabilities, including automation and project usage.

```APIDOC
Examples:
  Provides practical examples and demonstrations of gptme's capabilities, including automation and project usage.

Demos:
  Showcases various use cases and demonstrations of gptme in action.
```

--------------------------------

### Global Configuration Example

Source: https://gptme.org/docs/llms-full

Example of the global configuration file (`~/.config/gptme/config.toml`). It includes settings for prompts, environment variables for API keys and models, and tool configurations.

```toml
[prompt]
about_user = "I am a curious human programmer."
response_preference = "Don't explain basic concepts"

[env]
# Uncomment to use Claude 3.5 Sonnet by default
#MODEL = "anthropic/claude-3-5-sonnet-20240620"

# One of these need to be set
# If none of them are, they will be prompted for on first start
OPENAI_API_KEY = ""
ANTHROPIC_API_KEY = ""
OPENROUTER_API_KEY = ""
XAI_API_KEY = ""
GEMINI_API_KEY = ""
GROQ_API_KEY = ""
DEEPSEEK_API_KEY = ""

# Uncomment to use with Ollama
#MODEL = "local/<model-name>"
#OPENAI_BASE_URL = "http://localhost:11434/v1"

# Uncomment to change tool configuration
#TOOL_FORMAT = "markdown" # Select the tool formal. One of `markdown`, `xml`, `tool`
#TOOL_ALLOWLIST = "save,append,patch,ipython,shell,browser"  # Comma separated list of allowed tools
#TOOL_MODULES = "gptme.tools,custom.tools" # List of python comma separated python module path
```

--------------------------------

### Browser Tool - Playwright Backend Installation

Source: https://gptme.org/docs/tools

Instructions for installing the Playwright backend for the Browser tool, including dependency management for Playwright browser binaries.

```bash
'gptme[browser]'
# We need to use the same version of Playwright as the one installed by gptme
# when downloading the browser binaries. gptme will attempt this automatically
PW_VERSION=$(pipx||' ')
pipxplaywright==$PW_VERSION
```

--------------------------------

### IPython Code Execution Examples

Source: https://gptme.org/docs/prompts

Demonstrates the usage of the IPython tool for executing Python code. It shows how to get the result of expressions and how to define and call functions within the IPython environment.

```text
User: What is 2 + 2?
Assistant:
```ipython
2 + 2
```
> System: Executed code block.
```result
4
```

User: compute fib 10
Assistant: To compute the 10th Fibonacci number, we can run the following code:
```ipython
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)
fib(10)
```
> System: Executed code block.
```result
55
```
```

--------------------------------

### GPTME Building Executables Guide

Source: https://gptme.org/docs/index

Instructions on how to build executable versions of gptme for different platforms.

```APIDOC
Building Executables:
  Instructions on how to build executable versions of gptme for different platforms.
```

--------------------------------

### Global Configuration Example

Source: https://gptme.org/docs/config

An example of the global configuration file (`~/.config/gptme/config.toml`). It demonstrates settings for prompts, default models, API keys for various providers, and tool configurations.

```toml
[prompt]
about_user="I am a curious human programmer."
response_preference="Don't explain basic concepts"

[env]
# Uncomment to use Claude 3.5 Sonnet by default
#MODEL = "anthropic/claude-3-5-sonnet-20240620"

# One of these need to be set
# If none of them are, they will be prompted for on first start
OPENAI_API_KEY=""
ANTHROPIC_API_KEY=""
OPENROUTER_API_KEY=""
XAI_API_KEY=""
GEMINI_API_KEY=""
GROQ_API_KEY=""
DEEPSEEK_API_KEY=""

# Uncomment to use with Ollama
#MODEL = "local/<model-name>"
#OPENAI_BASE_URL = "http://localhost:11434/v1"

# Uncomment to change tool configuration
#TOOL_FORMAT = "markdown" # Select the tool formal. One of `markdown`, `xml`, `tool`
#TOOL_ALLOWLIST = "save,append,patch,ipython,shell,browser"  # Comma separated list of allowed tools
#TOOL_MODULES = "gptme.tools,custom.tools" # List of python comma separated python module path

```

--------------------------------

### gptme Quick Examples

Source: https://gptme.org/docs/llms-full

Demonstrates various use cases of gptme, including creating applications, working with files and code, development workflows, and chaining tasks.

```bash
# Create applications and games
gptme 'write a web app to particles.html which shows off an impressive and colorful particle effect using three.js'
gptme 'create a performant n-body simulation in rust'

# Work with files and code
gptme 'summarize this' README.md
gptme 'refactor this' main.py
gptme 'what do you see?' image.png  # vision

# Development workflows
git status -vv | gptme 'commit'
make test | gptme 'fix the failing tests'
gptme 'implement this' https://github.com/gptme/gptme/issues/286

# Chain multiple tasks
gptme 'make a change' - 'test it' - 'commit it'

# Resume conversations
gptme -r
```

--------------------------------

### Project Creation and Prompt Chaining

Source: https://gptme.org/docs/examples

Demonstrates creating new projects with gptme and chaining multiple prompts together for sequential tasks, as well as resuming conversations.

```shell
gptme'create a performant n-body simulation in rust'

# chaining prompts
gptme'make a change''test it''commit it'
gptme'show me something cool in the python repl''something cooler''something even cooler'

# resume the last conversation
gptme
```

--------------------------------

### Project Configuration Example

Source: https://gptme.org/docs/llms-full

Example of a project-specific configuration file (`gptme.toml`). It allows overriding global settings for a particular project, such as including specific files in the context or setting a project-specific prompt.

```toml
files = ["README.md", "Makefile"]
prompt = "This is gptme."
```

--------------------------------

### GPTME Server Guide

Source: https://gptme.org/docs/index

Details on running and managing the gptme server, including deployment and operational aspects.

```APIDOC
Server:
  Details on running and managing the gptme server, including deployment and operational aspects.
```

--------------------------------

### Pre-commit Integration Workflow Example

Source: https://gptme.org/docs/usage

Demonstrates a typical workflow where gptme integrates with pre-commit to automatically fix code quality issues identified during the commit process. This includes creating a file, running checks, and applying patches.

```python
def my_function(x, y):
    return x + y
```

```bash
typecheck................................................................Failed
- hook id: typecheck
- exit code: 1
main.py: error: Function is missing type hints
```

```python
def my_function(x: int, y: int) -> int:
    return x + y
```

--------------------------------

### GPTME Projects Guide

Source: https://gptme.org/docs/index

Explains how to manage and utilize projects within the gptme framework.

```APIDOC
Projects:
  Explains how to manage and utilize projects within the gptme framework.
```

--------------------------------

### GPTME Configuration Guide

Source: https://gptme.org/docs/index

Explains how to configure gptme, including settings for providers, agents, and other operational parameters.

```APIDOC
Configuration:
  Explains how to configure gptme, including settings for providers, agents, and other operational parameters.
```

--------------------------------

### GPTMe Finetuning Steps

Source: https://gptme.org/docs/index

A guide to the process of finetuning a model with GPTMe, covering data preparation and the finetuning process itself.

```APIDOC
Finetuning:

Step 1: Gather the data
  Instructions on collecting and preparing data for finetuning.

Step 2: Prepare the data
  Details on formatting the data according to GPTMe requirements.

Step 3: Fine-tune the model
  Guidance on executing the finetuning process.

Model suggestions:
  Recommendations for models suitable for finetuning.
```

--------------------------------

### Building gptme-server Executable

Source: https://gptme.org/docs/llms-full

Steps to build a standalone executable for gptme-server using Poetry and PyInstaller, including dependency installation and the build command.

```bash
# Install dependencies (including PyInstaller):
poetry install --extras server --with dev

# Build the executable:
make build-server-exe

# Or manually:
./scripts/build_server_executable.sh

# Find the executable in the dist/ directory:
ls -la dist/gptme-server*
```

--------------------------------

### Browser Interaction Examples

Source: https://gptme.org/docs/tools

Demonstrates how to use gptme's browser tools to read URLs, search for information, take screenshots, and check console logs. These examples showcase a conversational flow between a user and an assistant.

```python
read_url('https://gptme.org/docs/')
```

```python
read_url('https://superuserlabs.org/')
```

```python
search('ActivityWatch founder')
```

```python
search('latest developments in AI', 'perplexity')
```

```python
screenshot_url('https://activitywatch.net')
```

```python
read_url('https://example.com')
```

```python
read_logs()
```

--------------------------------

### GPTMe GitHub Bot Workflow Example

Source: https://gptme.org/docs/llms-full

An example GitHub Actions workflow file demonstrating how to use the `gptme/gptme/.github/actions/bot` composite action to run GPTMe in response to issue comments. It includes checkout, bot action execution, and necessary permissions.

```yaml
name: gptme-bot

on:
  issue_comment:
    types: [created]

permissions: write-all

jobs:
  run-bot:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: run gptme-bot action
        uses: gptme/gptme/.github/actions/bot@master
        with:
          openai_api_key: ${{ secrets.OPENAI_API_KEY }}
          github_token: ${{ secrets.GITHUB_TOKEN }}
          allowlist: "erikbjare"
```

--------------------------------

### Basic gptme Commands

Source: https://gptme.org/docs/examples

Demonstrates fundamental gptme commands for tasks like writing files, summarizing, refactoring, and vision-based analysis.

```shell
'write a web app to particles.html which shows off an impressive and colorful particle effect using three.js'
gptme'render mandelbrot set to mandelbrot.png'
gptme'summarize this'
gptme'refactor this'
gptme'what do you see?'# vision
```

--------------------------------

### Creating New Projects with gptme

Source: https://gptme.org/docs/llms-full

Example of using gptme to generate new projects, such as a performant n-body simulation in Rust.

```bash
gptme 'create a performant n-body simulation in rust'
```

--------------------------------

### GPTME Usage Guide

Source: https://gptme.org/docs/index

Explains how to use gptme for various tasks, including command-line usage and common workflows.

```APIDOC
Usage:
  Explains how to use gptme for various tasks, including command-line usage and common workflows.
```

--------------------------------

### Interacting with Git and Files

Source: https://gptme.org/docs/examples

Shows how gptme can be used with Git commands and interact with files via stdin or by exploring the file system.

```shell
git|'fix TODOs'
git|'commit'
maketest|'fix the failing tests'
gptme'explore'
gptme'take a screenshot and tell me what you see'
gptme'suggest improvements to my vimrc'
```

--------------------------------

### Create and Modify Files with GPTME

Source: https://gptme.org/docs/llms-full

Examples of using gptme to create new files and apply patches for modifications.

```python
```life.py
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
...
```
```

```patch
```patch life.py
...
```
```

```python
```save main.py
def my_function(x, y):
    return x + y
```
```

--------------------------------

### GPTME Prompts Guide

Source: https://gptme.org/docs/index

Details how to write and manage prompts for gptme, including best practices and advanced techniques.

```APIDOC
Prompts:
  Details how to write and manage prompts for gptme, including best practices and advanced techniques.
```

--------------------------------

### Basic Custom Tool Example

Source: https://gptme.org/docs/custom_tool

A minimal example demonstrating the creation of a custom tool using the ToolSpec class. It includes the necessary imports, an execute function, and the ToolSpec definition with parameters.

```python
from gptme.tools import ToolSpec, Parameter, ToolUse
from gptme.message import Message

def execute(code, args, kwargs, confirm):
    name = kwargs.get('name', 'World')
    yield Message('system', f"Hello, {name}!")

tool = ToolSpec(
    name="hello",
    desc="A simple greeting tool",
    instructions="Greets the user by name",
    execute=execute,
    block_types=["hello"],
    parameters=[
        Parameter(
            name="name",
            type="string",
            description="Name to greet",
            required=False,
        ),
    ],
)

```

--------------------------------

### Build gptme-server Executable

Source: https://gptme.org/docs/building

Instructions for building the gptme-server standalone executable using PyInstaller. This involves installing dependencies and then running the build command.

```bash
# Install dependencies (including PyInstaller)
pip install -r requirements.txt
pip install pyinstaller

# Build the executable
python -m PyInstaller scripts/pyinstaller/gptme-server.spec
```

--------------------------------

### GPTME Finetuning Guide

Source: https://gptme.org/docs/index

Covers the process of finetuning models for use with gptme, including data preparation and training procedures.

```APIDOC
Finetuning:
  Covers the process of finetuning models for use with gptme, including data preparation and training procedures.
```

--------------------------------

### GPTME Automation Guide

Source: https://gptme.org/docs/index

Details how to automate tasks and workflows using gptme.

```APIDOC
Automation:
  Details how to automate tasks and workflows using gptme.
```

--------------------------------

### GPTME GitHub Bot Guide

Source: https://gptme.org/docs/index

Information on setting up and using the GitHub bot for integrating gptme with GitHub workflows.

```APIDOC
GitHub Bot:
  Information on setting up and using the GitHub bot for integrating gptme with GitHub workflows.
```

--------------------------------

### View Screenshot Immediately

Source: https://gptme.org/docs/prompts

An example of how to take a screenshot and immediately view it within the chat interface using the IPython tool.

```ipython
view_image(screenshot())
```

--------------------------------

### GPTME Providers Guide

Source: https://gptme.org/docs/index

Details the different language model providers that gptme can integrate with.

```APIDOC
Providers:
  Details the different language model providers that gptme can integrate with.
```

--------------------------------

### GPTMe Chat Commands

Source: https://gptme.org/docs/usage

A list of slash commands available within the GPTMe chat interface for managing conversations, editing, and getting help.

```APIDOC
GPTMe Chat Commands:

  /undo
    - Undoes the last action performed in the chat.

  /log
    - Displays the complete conversation history.

  /tools
    - Lists all the tools currently available for use.

  /edit
    - Opens the conversation in the configured text editor for modifications.

  /rename
    - Allows renaming the current conversation.

  /fork
    - Creates a duplicate or copy of the current conversation.

  /summarize
    - Generates a summary of the ongoing conversation.

  /replay
    - Re-executes code blocks that were previously run in the conversation.

  /help
    - Displays a help message with available commands and usage information.

  /exit
    - Terminates the GPTMe program.
```

--------------------------------

### gptme Documentation Links

Source: https://gptme.org/docs/llms

Provides a list of links to various documentation pages for the gptme project, covering a wide range of topics from getting started to advanced features and contributing guidelines.

```markdown
# gptme

## Docs

- [gptme documentation](https://gptme.org/docs/index.html)
- [Getting Started](https://gptme.org/docs/getting-started.html)
- [Usage](https://gptme.org/docs/usage.html)
- [Examples](https://gptme.org/docs/examples.html)
- [Demos](https://gptme.org/docs/demos.html)
- [Automation](https://gptme.org/docs/automation.html)
- [Projects](https://gptme.org/docs/projects.html)
- [Tools](https://gptme.org/docs/tools.html)
- [Configuration](https://gptme.org/docs/config.html)
- [Providers](https://gptme.org/docs/providers.html)
- [Agents](https://gptme.org/docs/agents.html)
- [Server](https://gptme.org/docs/server.html)
- [MCP](https://gptme.org/docs/mcp.html)
- [CLI Reference](https://gptme.org/docs/cli.html)
- [Contributing](https://gptme.org/docs/contributing.html)
- [Building Executables](https://gptme.org/docs/building.html)
- [Prompts](https://gptme.org/docs/prompts.html)
- [Evals](https://gptme.org/docs/evals.html)
- [GitHub Bot](https://gptme.org/docs/bot.html)
- [Finetuning](https://gptme.org/docs/finetuning.html)
- [Custom Tools](https://gptme.org/docs/custom_tool.html)
- [API Reference](https://gptme.org/docs/api.html)
- [Alternatives](https://gptme.org/docs/alternatives.html)
- [Are we tiny?](https://gptme.org/docs/arewetiny.html)
- [Timeline](https://gptme.org/docs/timeline.html)
- [<no title>](https://gptme.org/docs/automation/example_activity_summary.html)
- [<no title>](https://gptme.org/docs/automation/example_code_review.html)
- [<no title>](https://gptme.org/docs/computer-use-warning.html)
```

--------------------------------

### Running the gptme-server Executable

Source: https://gptme.org/docs/llms-full

How to run the standalone gptme-server executable and display its help message.

```bash
# Run the server
./dist/gptme-server --host 0.0.0.0 --port 5700

# Show help
./dist/gptme-server --help
```

--------------------------------

### Install gptme using pipx

Source: https://gptme.org/docs/llms-full

Installs the gptme tool using pipx, a Python application isolation tool. If pipx is not installed, it provides instructions to install it first.

```bash
pipx install gptme
```

```bash
pip install --user pipx
```

--------------------------------

### Install Dependencies with Pipx

Source: https://gptme.org/docs/agents

Installs the required dependencies for GPTMe using pipx, a tool for installing and running Python applications in isolated environments. This ensures easy management and isolation of the project's dependencies.

```shell
# Install required dependencies
pipx# or `pipx install -e ./gptme` to install from local source
pipx
```

--------------------------------

### Install gptme-rag CLI

Source: https://gptme.org/docs/tools

Installs the gptme-rag command-line interface using pipx.

```bash
pipx install gptme-rag
```

--------------------------------

### Installation on Arch Linux

Source: https://gptme.org/docs/tools

Installs the 'xdotool' package on Arch Linux, a dependency for controlling keyboard and mouse.

```bash
sudo pacman -S xdotool
```

--------------------------------

### Installation on macOS

Source: https://gptme.org/docs/tools

Installs the 'cliclick' tool on macOS using Homebrew, which is used for mouse and keyboard automation.

```shell
brew install cliclick
```

--------------------------------

### GPTME Custom Tools Guide

Source: https://gptme.org/docs/index

Guides users on creating and integrating custom tools with gptme to extend its functionality.

```APIDOC
Custom Tools:
  Guides users on creating and integrating custom tools with gptme to extend its functionality.
```

--------------------------------

### Install GPTMe with TTS Extras

Source: https://gptme.org/docs/tools

Installs the GPTMe package with additional dependencies required for Text-to-Speech (TTS) functionality.

```bash
pipx[tts]
```

--------------------------------

### Install xdotool on Debian/Ubuntu

Source: https://gptme.org/docs/tools

Installs the xdotool package, which is required for computer interaction tools on Linux environments using X11.

```bash
# On Debian/Ubuntu
sudo apt install xdotool
```

--------------------------------

### Type Hinting Fix Example

Source: https://gptme.org/docs/llms-full

A patch example demonstrating how gptme can fix code by adding type hints to a Python function.

```patch
<<<<<<< ORIGINAL
def my_function(x, y):
=======
def my_function(x: int, y: int) -> int:
>>>>>>> UPDATED
```

--------------------------------

### Basic gptme Usage

Source: https://gptme.org/docs/llms-full

Demonstrates fundamental gptme commands for generating web applications, rendering images, and interacting with files.

```bash
gptme 'write a web app to particles.html which shows off an impressive and colorful particle effect using three.js'
gptme 'render mandelbrot set to mandelbrot.png'
```

--------------------------------

### Execute Shell Commands

Source: https://gptme.org/docs/prompts

Provides examples of executing various shell commands, including listing directory contents, inspecting files, and creating Vue projects. It also demonstrates proper quoting for complex commands.

```shell
ls
```

```shell
git
```

```shell
cat
```

```shell
npm create vue@latest fancy-project -- --typescript --pinia
```

```shell
echo'Content with `backticks` and $variables that should not be interpreted'
```

--------------------------------

### Basic Custom Tool Example

Source: https://gptme.org/docs/llms-full

A minimal example demonstrating how to create a custom tool in gptme using the ToolSpec class. This tool provides a simple greeting functionality.

```python
from gptme.tools import ToolSpec, Parameter, ToolUse
from gptme.message import Message

def execute(code, args, kwargs, confirm):
    name = kwargs.get('name', 'World')
    yield Message('system', f"Hello, {name}!")

tool = ToolSpec(
    name="hello",
    desc="A simple greeting tool",
    instructions="Greets the user by name",
    execute=execute,
    block_types=["hello"],
    parameters=[
        Parameter(
            name="name",
            type="string",
            description="Name to greet",
            required=False,
        ),
    ],
)
```

--------------------------------

### Create and Modify Files with GPTMe

Source: https://gptme.org/docs/usage

Demonstrates how to use GPTMe to create new files and apply changes to existing ones. The assistant generates code for new files and patches for modifications, with system confirmations for saved actions.

```python
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
...
```

--------------------------------

### GPTME TTS Speak Function with Examples

Source: https://gptme.org/docs/tools

Demonstrates the usage of the `speak` function from the GPTME TTS module, including setting volume and speed, and examples of non-blocking and interrupting speech.

```python
from gptme.tools.tts import speak, set_speed, set_volume

set_volume(0.8)  # Set comfortable volume
set_speed(1.2)   # Slightly faster speech

speak("Hello, world!")  # Non-blocking by default
speak("Important message!", interrupt=True)  # Interrupts previous speech
```

--------------------------------

### Run gptme Tests

Source: https://gptme.org/docs/contributing

Instructions for running the test suite. It details how to execute all tests, including those that require LLM calls, and mentions the availability of integration tests.

```bash
make test
```

```bash
make test SLOW=true
```

--------------------------------

### GPTME Tools Guide

Source: https://gptme.org/docs/index

Information on the various tools supported and integrated with gptme.

```APIDOC
Tools:
  Information on the various tools supported and integrated with gptme.
```

--------------------------------

### GPTMe Building Executables

Source: https://gptme.org/docs/index

Instructions and usage details for building GPTMe executables, including the server, distribution, and cleaning build artifacts.

```APIDOC
Building Executables:

Building gptme-server Executable:
  Instructions for compiling the gptme-server binary.

Usage:
  Details on how to use the built executables.

Distribution:
  Information on how to distribute the compiled binaries.

Cleaning Build Artifacts:
  Commands to remove temporary build files.

Customization:
  Options for customizing the build process.
```

--------------------------------

### GPTME Agents Guide

Source: https://gptme.org/docs/index

Explains the concept of agents within gptme and how to configure and manage them.

```APIDOC
Agents:
  Explains the concept of agents within gptme and how to configure and manage them.
```

--------------------------------

### GPTMe Configuration File Example

Source: https://gptme.org/docs/llms-full

Illustrates the structure of the gptme.toml configuration file, which specifies core files to be included in the agent's context and the command used for dynamic context generation.

```toml
# Example gptme.toml structure

[context]
files = ["README.md", "ABOUT.md"]
context_cmd = "./scripts/generate_context.sh"
```

--------------------------------

### Get Cursor Position

Source: https://gptme.org/docs/prompts

Retrieves the current X and Y coordinates of the mouse cursor.

```ipython
computer("cursor_position")
```

--------------------------------

### GPTMe Model Reasoning and Simple Output

Source: https://gptme.org/docs/genindex

Options for `gptme-util-models-list`. `--reasoning` displays reasoning behind model choices, and `--simple` provides a simplified output format.

```cli
--reasoning
  [gptme-util-models-list command line option](https://gptme.org/docs/cli.html#cmdoption-gptme-util-models-list-reasoning)
--simple
  [gptme-util-models-list command line option](https://gptme.org/docs/cli.html#cmdoption-gptme-util-models-list-simple)
```

--------------------------------

### GPTMe CLI: Server Serve Options

Source: https://gptme.org/docs/genindex

Specifies command-line options for `gptme-server-serve`, used to start the GPTMe server, controlling host, port, CORS, and verbosity.

```APIDOC
gptme-server-serve

Options:
  --host TEXT               Host address for the server.
  --port INTEGER            Port number for the server.
  --cors-origin TEXT        CORS origin header value.
  --model TEXT              Specify the language model for the server.
  --tools TEXT              Specify tools to be available via the server.
  -v, --verbose             Enable verbose output for the server.
  --debug                   Enable debug mode for the server.
  -h, --help                Show this message and exit.
```

--------------------------------

### GPTMe Server Serve Command

Source: https://gptme.org/docs/cli

Starts a server and web UI for GPTMe. This command is experimental and not yet ready for general use. It allows configuration of debug mode, verbosity, default model, host, port, tools, and CORS origin.

```bash
gptme server serve [--debug] [-v|--verbose] [--model <model>] [--host <host>] [--port <port>] [--tools <tools>] [--cors-origin <cors_origin>]
```

--------------------------------

### Take Screenshot

Source: https://gptme.org/docs/prompts

Captures a screenshot of the current desktop.

```ipython
computer("screenshot")
```

--------------------------------

### Run 'hello' Eval with Docker

Source: https://gptme.org/docs/evals

This snippet demonstrates how to run the 'hello' evaluation using Docker, mounting a local directory for results. It requires setting the ANTHROPIC_API_KEY environment variable.

```bash
docker run --rm -it \
  -e ANTHROPIC_API_KEY=$ANTHROPIC_API_KEY \
  -v $(pwd)/eval_results:/app/eval_results \
  ghcr.io/gptme/gptme:latest \
  eval hello --model anthropic/claude-3-7-sonnet
```

--------------------------------

### Shell Command Execution

Source: https://gptme.org/docs/tools

Demonstrates how to execute shell commands using the 'shell' tool. It covers basic commands like 'ls' and 'git ls-files', as well as creating new projects with 'npm init vue@latest'. It also shows how to handle complex content with special characters using single quotes.

```shell
ls
```

```shell
git ls-files
```

```shell
npm init vue@latest fancy-project --yes -- --typescript --pinia
```

```shell
echo 'Content with `backticks` and $variables that should not be interpreted' > example.txt
```

--------------------------------

### Mouse and Cursor Operations

Source: https://gptme.org/docs/tools

Illustrates how to get the current mouse cursor position and perform clicks at that location.

```python
computer("cursor_position")
```

```python
computer("left_click")
```

--------------------------------

### GPTMe CLI: Tools Info Option

Source: https://gptme.org/docs/genindex

Option to get information about a specific tool in the GPTMe CLI.

```bash
gptme-util-tools-info TOOL_NAME
```

--------------------------------

### gptme File Interaction and URL Loading

Source: https://gptme.org/docs/llms-full

Demonstrates gptme's ability to explore local files, take screenshots, suggest configuration improvements, and process content from URLs.

```bash
gptme 'explore'
gptme 'take a screenshot and tell me what you see'
gptme 'suggest improvements to my vimrc'
gptme 'implement this' https://github.com/gptme/gptme/issues/286
```
Tokens:
Raw