Weave takes a different approach to building AI-powered applications in Go by treating AI capabilities as modular, hot-pluggable plugins on top of a microkernel architecture. Instead of baking in AI features tightly, it offers a layered platform where you can dynamically swap between models from OpenAI, Ollama, or ModelScope at runtime without restarting the system. This design lets developers rapidly build intelligent apps without wrestling with complex AI infrastructure.
Weave’s microkernel architecture with layered AI plugins
At its core, Weave is an application development platform written in Go, structured around a microkernel plus layered architecture pattern. The microkernel provides the minimal core system, while various functional modules — including AI capabilities — are implemented as independent plugins.
The platform uses the Gin web framework for its HTTP backend. All functional modules adhere to a unified Plugin interface, which enables hot-plugging: loading or unloading plugins without restarting the application. This is a powerful feature for development flexibility and system extensibility.
Plugins live in their own namespaces and the platform has built-in dependency and conflict resolution to manage interactions between plugins safely. This avoids the typical monolithic AI app where models and agents are fixed components.
Weave deeply integrates several AI technologies:
- Large Language Models (LLMs) with support for multiple providers such as OpenAI, Ollama, and ModelScope
- An Agent framework that supports tool calling and task planning for orchestrating complex workflows
- Retrieval-Augmented Generation (RAG) using RedisSearch as a vector database backend
This architecture means you can swap out the LLM provider dynamically at runtime, experiment with different AI agent implementations, or extend the system with new plugins without touching the core.
Technical strengths and design tradeoffs
The standout technical feature is the unified plugin system over a microkernel core. This is not common in Go projects, especially for AI applications, which often bundle AI logic tightly with the system.
The Plugin interface standardizes how modules register themselves and interact, allowing hot-plug behavior. The use of independent namespaces ensures plugins don’t interfere with each other’s state or data, which is crucial for stability.
Supporting multiple LLM providers with runtime switching adds flexibility for developers who want to compare model outputs or fall back between providers without downtime. The tradeoff is added complexity in managing API credentials, rate limits, and compatibility layers.
The Agent framework’s tool-calling and task-planning features allow building complex automation workflows, which can be layered on top of the core platform. This design supports extensibility but may require careful orchestration to avoid state inconsistencies.
Using RedisSearch as the vector database for RAG is a pragmatic choice, leveraging Redis’s speed and familiarity. However, it may not be as feature-rich as dedicated vector databases, limiting advanced similarity search capabilities.
The platform ships with Docker Compose setup that bundles MySQL, Redis, Prometheus, and Grafana — covering database, vector search, and observability needs out of the box. This reduces the operational burden to get started but may not fit every production environment.
Overall, the codebase strikes a balance between modularity, extensibility, and operational convenience, though it may be more suited for developers comfortable with Go and container orchestration.
Quick start with Docker Compose
Weave’s README provides a straightforward Docker Compose deployment method to get the full platform stack running quickly. This includes the Weave app, MySQL, RedisSearch vector database, Prometheus, and Grafana dashboards.
Here are the commands exactly as provided:
# Clone the repository
git clone https://github.com/liaotxcn/weave.git
cd weave
# (Optional) Create a .env file for environment variables
# Start all services with Docker Compose
docker-compose up -d
# Check running services status
docker-compose ps
# Useful commands to interact with logs and containers
docker-compose logs -f weave-app
docker-compose logs -f weave-mysql
docker-compose logs -f weave-redis
docker-compose exec weave-app /bin/sh
# Access MySQL container
# docker-compose exec weave-mysql mysql -u root -p
# Access Redis container
# docker-compose exec weave-redis redis-cli
# Rebuild and restart services if needed
docker-compose up --build -d
After startup, the backend API is accessible on http://localhost:8081, Prometheus at http://localhost:9090, and Grafana dashboards at http://localhost:3000 (default admin/admin).
This all-in-one approach lets you experiment with the platform and its AI plugins without manual setup of dependencies.
verdict
Weave is a solid choice if you want a Go-native platform that treats AI capabilities as modular plugins you can hot-swap at runtime. Its microkernel architecture is a notable design that supports extensibility and plugin isolation, which is rare in AI-focused Go projects.
The multi-model support and integrated Agent and RAG features provide a flexible foundation for building intelligent applications without managing AI infrastructure from scratch.
That said, the platform’s complexity and reliance on Docker Compose may limit its appeal to developers unfamiliar with container orchestration or those requiring lightweight deployments. The RedisSearch-based vector store is a practical but not cutting-edge choice.
For developers comfortable with Go, Docker, and AI workflows, Weave offers a practical, extensible system to build on. It’s worth exploring for projects that need dynamic AI plugin management and multi-model experimentation.
If you’re looking for a tightly integrated SaaS or single-model solution, other platforms might be simpler. But for those aiming to build a modular AI app platform in Go, Weave’s architecture and tooling are worth understanding and trying out.
Related Articles
- Building private AI workflows with the n8n self-hosted AI starter kit — Spin up a private AI agent stack in under 5 minutes with n8n’s self-hosted AI starter kit. Combines local LLMs, automati
- Scarf: a native Swift companion app for Hermes AI with smooth multimodal input and real-time monitoring — Scarf is a Swift native macOS and iOS app that provides a GUI for the Hermes AI agent, featuring SSH connectivity, effic
- Ollama: a unified CLI and API platform for local large language models — Ollama simplifies running and managing open-source large language models locally with a unified CLI and REST API, suppor
- Inside agents: a granular multi-agent orchestration system with PluginEval quality assurance — Explore agents, a Python-based multi-agent orchestration repo featuring 184 AI agents, 78 plugins, and a three-layer Plu
- Langchain-Chatchat: A model-agnostic orchestration layer for Chinese-language RAG and Agents — Langchain-Chatchat offers a flexible, offline-capable orchestration layer for multiple Chinese LLMs and RAG approaches,
→ GitHub Repo: liaotxcn/Weave ⭐ 327 · Go