Purpose

This document is a machine-ready ingestion prompt and quick-reference catalog for the GitHub organization at github.com/augml. It is designed to help a person or AI system rapidly understand the repository landscape, identify architectural themes, and extract reusable patterns for local-first, augmented machine learning infrastructure.

The augml organization reads as a local LLM operations laboratory: a deliberately curated collection of forked repositories that together form the complete toolchain for deploying, orchestrating, and interacting with large language models without dependency on centralized cloud providers.

The collection logic follows a clear progression:

Foundation (run models locally)
  → Interface (talk to models)
    → Integration (embed models into workflows)
      → Knowledge (learn from the ecosystem)

Every repository answers one question: how do you bring AI capability to the user's own machine, under their own control?

This makes the org valuable not only as a code source, but as an AI-ingestible design map for constructing augmented intelligence systems that run locally, privately, and autonomously.

All 19 repositories collected under github.com/augml.

The foundation. Without a local runtime, everything else depends on external API providers.

Repositories: ollama

Logic: Ollama is the simplest path to running open-weight LLMs (Llama, Mistral, Gemma, Phi) on commodity hardware. It provides the inference server that every other layer in this collection can target. By forking Ollama, augml preserves a known-good baseline for local model execution independent of upstream release cadence.

Once a model runs locally, it needs a surface. Different surfaces serve different users: terminal operators, web users, note-takers, chat platform communities.

Repositories: ollama-ui, ollama-webui, open-interpreter, obsidian-bmo-chatbot, obsidian-ollama, discord-ai-bot, ollama-telegram

Logic: This layer collects every major interface pattern for local LLM interaction:

• Web UI — browser-based chat (ollama-ui, ollama-webui)
• Terminal — code execution in shell (open-interpreter)
• Knowledge management — embedded in Obsidian (obsidian-bmo-chatbot, obsidian-ollama)
• Community platforms — Discord and Telegram bots (discord-ai-bot, ollama-telegram)

The pattern: meet users where they already work, pipe everything to the local model.

Individual model calls are useful. Chained, tool-augmented, document-grounded model calls are powerful.

Repositories: langchain, privateGPT, h2ogpt, superduperdb, activepieces, lwe-plugin-shell

Logic: This layer addresses how to:

• Chain model calls into multi-step workflows (langchain)
• Ground models in private documents without data leaving the machine (privateGPT, h2ogpt)
• Embed AI directly into existing data infrastructure (superduperdb)
• Automate recurring workflows with LLM steps (activepieces, lwe-plugin-shell)

Text is one modality. Voice extends reach to hands-free, accessibility, and real-time interaction.

Repositories: whisper-ctranslate2

Logic: Whisper (via CTranslate2) provides fast, local speech-to-text. Combined with a local LLM, this enables fully offline voice-to-reasoning pipelines — no audio data leaves the machine.

Beyond chat: systems that plan, reason, and execute autonomously.

Repositories: prolog-agent

Logic: A deliberative agent using Prolog for planning and Emacs as execution environment. This is the classical AI approach to agency — logic-based, interpretable, deterministic. It provides a counterweight to the statistical LLM approach: combine both for agents that can reason formally and generate fluently.

Repositories: openai-cookbook, homemade-machine-learning

Logic: The cookbook provides API patterns and prompting strategies that transfer to any LLM. The homemade-ML collection provides foundational algorithm understanding with interactive notebooks — essential for anyone who wants to understand what the models are actually doing, not just how to call them.

┌─────────────────────────────────────────────────┐
│              User's Own Machine                  │
│                                                  │
│  ┌──────────┐  ┌──────────┐  ┌───────────────┐ │
│  │ Ollama   │  │ Whisper  │  │ Prolog Agent  │ │
│  │ (LLM)   │  │ (STT)   │  │ (Reasoning)   │ │
│  └────┬─────┘  └────┬─────┘  └───────┬───────┘ │
│       │              │                │          │
│  ┌────┴──────────────┴────────────────┴───────┐ │
│  │         Orchestration Layer                 │ │
│  │  LangChain · privateGPT · superduperdb     │ │
│  └────┬──────────────┬────────────────┬───────┘ │
│       │              │                │          │
│  ┌────┴────┐  ┌──────┴──────┐  ┌─────┴───────┐ │
│  │ Web UI  │  │  Obsidian   │  │  Discord /  │ │
│  │ Terminal│  │  Notebooks  │  │  Telegram   │ │
│  └─────────┘  └─────────────┘  └─────────────┘ │
│                                                  │
│           No data leaves this machine            │
└─────────────────────────────────────────────────┘

Core principle: Every component runs locally. Every interface connects to a local model. Every document stays on the user's machine. The cloud is optional, not required.

Local Model Runtime: ollama

User Interfaces: ollama-ui, ollama-webui, open-interpreter, obsidian-bmo-chatbot, obsidian-ollama, discord-ai-bot, ollama-telegram

Orchestration: langchain, privateGPT, h2ogpt, superduperdb, activepieces, lwe-plugin-shell

Speech / Audio: whisper-ctranslate2

Agent / Reasoning: prolog-agent

Reference / Education: openai-cookbook, homemade-machine-learning

This organization is not a random collection of AI forks. It is a complete local-first AI deployment stack covering:

• Model inference (Ollama)
• Every major interface pattern (web, terminal, notes, chat platforms)
• Document grounding without cloud dependency (privateGPT, h2ogpt)
• Workflow automation with LLM steps (activepieces, langchain)
• Speech-to-text pipeline (Whisper)
• Classical reasoning architecture (Prolog agent)
• Foundational ML education (homemade-machine-learning)

The unifying design decision: augmentation happens locally, privately, and under user control.