github.com/mudler/LocalAGI @v2.9.0 sqlite

Your AI. Your Hardware. Your Rules

Try on

Create customizable AI assistants, automations, chat bots and agents that run 100% locally. No need for agentic Python libraries or cloud service keys, just bring your GPU (or even just CPU) and a web browser.

LocalAGI is a powerful, self-hostable AI Agent platform that allows you to design AI automations without writing code. Create Agents with a couple of clicks, connect via MCP, and use built-in Skills (manage skills in the Web UI and enable them per agent). Every agent exposes a complete drop-in replacement for OpenAI's Responses APIs with advanced agentic capabilities. No clouds. No data leaks. Just pure local AI that works on consumer-grade hardware (CPU and GPU). Skills follow the skillserver format and can be created, imported, or synced from git.

🛡️ Take Back Your Privacy

Are you tired of AI wrappers calling out to cloud APIs, risking your privacy? So were we.

LocalAGI ensures your data stays exactly where you want it—on your hardware. No API keys, no cloud subscriptions, no compromise.

🌟 Key Features

• 🎛 No-Code Agents: Easy-to-configure multiple agents via Web UI.
• 🖥 Web-Based Interface: Simple and intuitive agent management.
• 🤖 Advanced Agent Teaming: Instantly create cooperative agent teams from a single prompt.
• 📡 Connectors: Built-in integrations with Discord, Slack, Telegram, GitHub Issues, and IRC.
• 🛠 Comprehensive REST API: Seamless integration into your workflows. Every agent created will support OpenAI Responses API out of the box.
• 📚 Short & Long-Term Memory: Built-in knowledge base (RAG) for collections, file uploads, and semantic search. Manage collections in the Web UI under Knowledge base; agents with "Knowledge base" enabled use it automatically (implementation uses LocalRecall libraries).
• 🧠 Planning & Reasoning: Agents intelligently plan, reason, and adapt.
• 🔄 Periodic Tasks: Schedule tasks with cron-like syntax.
• 💾 Memory Management: Control memory usage with options for long-term and summary memory.
• 🖼 Multimodal Support: Ready for vision, text, and more.
• 🔧 Extensible Custom Actions: Easily script dynamic agent behaviors in Go (interpreted, no compilation!).
• 📚 Built-in Skills: Manage reusable agent skills in the Web UI (create, edit, import/export, git sync). Enable "Skills" per agent to inject skill tools and the skill list into the agent.
• 🛠 Fully Customizable Models: Use your own models or integrate seamlessly with LocalAI.
• 📊 Observability: Monitor agent status and view detailed observable updates in real-time.

🛠️ Quickstart

# Clone the repository
git clone https://github.com/mudler/LocalAGI
cd LocalAGI

# CPU setup (default)
docker compose up

# NVIDIA GPU setup
docker compose -f docker-compose.nvidia.yaml up

# Intel GPU setup (for Intel Arc and integrated GPUs)
docker compose -f docker-compose.intel.yaml up

# AMD GPU setup
docker compose -f docker-compose.amd.yaml up

# Start with a specific model (see available models in models.localai.io, or localai.io to use any model in huggingface)
MODEL_NAME=gemma-3-12b-it docker compose up

# NVIDIA GPU setup with custom multimodal and image models
MODEL_NAME=gemma-3-12b-it \
MULTIMODAL_MODEL=moondream2-20250414 \
IMAGE_MODEL=flux.1-dev-ggml \
docker compose -f docker-compose.nvidia.yaml up

Now you can access and manage your agents at http://localhost:8080

Still having issues? see this Youtube video: https://youtu.be/HtVwIxW3ePg

Videos

📚🆕 Local Stack Family

🆕 LocalAI is now part of a comprehensive suite of AI tools designed to work together:

	LocalAI LocalAI is the free, Open Source OpenAI alternative. LocalAI act as a drop-in replacement REST API that's compatible with OpenAI API specifications for local AI inferencing. Does not require GPU.
	LocalRecall A REST-ful API and knowledge base management system. LocalAGI embeds this functionality: the Web UI includes a Knowledge base section and the same collections API, so you no longer need to run LocalRecall separately.

🖥️ Hardware Configurations

LocalAGI supports multiple hardware configurations through Docker Compose profiles:

CPU (Default)

• No special configuration needed
• Runs on any system with Docker
• Best for testing and development
• Supports text models only

NVIDIA GPU

• Requires NVIDIA GPU and drivers
• Uses CUDA for acceleration
• Best for high-performance inference
• Supports text, multimodal, and image generation models
• Run with: docker compose -f docker-compose.nvidia.yaml up
• Default models:
• Text: gemma-3-4b-it-qat
• Multimodal: moondream2-20250414
• Image: sd-1.5-ggml
• Environment variables:
• MODEL_NAME: Text model to use
• MULTIMODAL_MODEL: Multimodal model to use
• IMAGE_MODEL: Image generation model to use
• LOCALAI_SINGLE_ACTIVE_BACKEND: Set to true to enable single active backend mode

Intel GPU

• Supports Intel Arc and integrated GPUs
• Uses SYCL for acceleration
• Best for Intel-based systems
• Supports text, multimodal, and image generation models
• Run with: docker compose -f docker-compose.intel.yaml up
• Default models:
• Text: gemma-3-4b-it-qat
• Multimodal: moondream2-20250414
• Image: sd-1.5-ggml
• Environment variables:
• MODEL_NAME: Text model to use
• MULTIMODAL_MODEL: Multimodal model to use
• IMAGE_MODEL: Image generation model to use
• LOCALAI_SINGLE_ACTIVE_BACKEND: Set to true to enable single active backend mode

Customize models

You can customize the models used by LocalAGI by setting environment variables when running docker-compose. For example:

# CPU with custom model
MODEL_NAME=gemma-3-12b-it docker compose up

# NVIDIA GPU with custom models
MODEL_NAME=gemma-3-12b-it \
MULTIMODAL_MODEL=moondream2-20250414 \
IMAGE_MODEL=flux.1-dev-ggml \
docker compose -f docker-compose.nvidia.yaml up

# Intel GPU with custom models
MODEL_NAME=gemma-3-12b-it \
MULTIMODAL_MODEL=moondream2-20250414 \
IMAGE_MODEL=sd-1.5-ggml \
docker compose -f docker-compose.intel.yaml up

# With custom actions directory
LOCALAGI_CUSTOM_ACTIONS_DIR=/app/custom-actions docker compose up

If no models are specified, it will use the defaults: - Text model: gemma-3-4b-it-qat - Multimodal model: moondream2-20250414 - Image model: sd-1.5-ggml

Good (relatively small) models that have been tested are:

• qwen_qwq-32b (best in co-ordinating agents)
• gemma-3-12b-it
• gemma-3-27b-it

🏆 Why Choose LocalAGI?

• ✓ Ultimate Privacy: No data ever leaves your hardware.
• ✓ Flexible Model Integration: Supports GGUF, GGML, and more thanks to LocalAI.
• ✓ Developer-Friendly: Rich APIs and intuitive interfaces.
• ✓ Effortless Setup: Simple Docker compose setups and pre-built binaries.
• ✓ Feature-Rich: From planning to multimodal capabilities, connectors for Slack, MCP support, built-in Skills, LocalAGI has it all.

🌟 Screenshots

Powerful Web UI

Connectors Ready-to-Go

📖 Full Documentation

Explore detailed documentation including: - Installation Options - REST API Documentation - Connector Configuration - Agent Configuration - Skills

Environment Configuration

LocalAGI supports environment configurations. Note that these environment variables needs to be specified in the localagi container in the docker-compose file to have effect.

For the built-in knowledge base, optional env (defaults use LOCALAGI_STATE_DIR): COLLECTION_DB_PATH, FILE_ASSETS, VECTOR_ENGINE (e.g. chromem, postgres), EMBEDDING_MODEL, DATABASE_URL (when VECTOR_ENGINE=postgres).

Skills are stored in a fixed skills subdirectory under LOCALAGI_STATE_DIR (e.g. /pool/skills in Docker). Git repo config for skills lives in that directory. No extra environment variables are required.

Installation Options

Pre-Built Binaries

Download ready-to-run binaries from the Releases page.

Source Build

Requirements: - Go 1.20+ - Git - Bun 1.2+

# Clone repo
git clone https://github.com/mudler/LocalAGI.git
cd LocalAGI

# Build it
cd webui/react-ui && bun i && bun run build
cd ../..
go build -o localagi

# Run it
./localagi

Using as a Library

LocalAGI can be used as a Go library to programmatically create and manage AI agents. Let's start with a simple example of creating a single agent:

Basic Usage: Single Agent

import (
    "github.com/mudler/LocalAGI/core/agent"
    "github.com/mudler/LocalAGI/core/types"
)

// Create a new agent with basic configuration
agent, err := agent.New(
    agent.WithModel("gpt-4"),
    agent.WithLLMAPIURL("http://localhost:8080"),
    agent.WithLLMAPIKey("your-api-key"),
    agent.WithSystemPrompt("You are a helpful assistant."),
    agent.WithCharacter(agent.Character{
        Name: "my-agent",
    }),
    agent.WithActions(
        // Add your custom actions here
    ),
    agent.WithStateFile("./state/my-agent.state.json"),
    agent.WithCharacterFile("./state/my-agent.character.json"),
    agent.WithTimeout("10m"),
    agent.EnableKnowledgeBase(),
    agent.EnableReasoning(),
)

if err != nil {
    log.Fatal(err)
}

// Start the agent
go func() {
    if err := agent.Run(); err != nil {
        log.Printf("Agent stopped: %v", err)
    }
}()

// Stop the agent when done
agent.Stop()

This basic example shows how to: - Create a single agent with essential configuration - Set up the agent's model and API connection - Configure basic features like knowledge base and reasoning - Start and stop the agent

Advanced Usage: Agent Pools

For managing multiple agents, you can use the AgentPool system: