Weave: A Go Application Development Platform with Microkernel Architecture and Integrated AI Stack

The Problem Weave Is Built to Solve

Building an application that combines a REST API gateway, multiple AI providers, a plugin-extensible service layer and a monitoring stack typically means wiring together separate frameworks, writing glue code for each, and deciding at every step how to structure the result. Weave offers a pre-wired Go backend where all these concerns have assigned places. The core is a minimal kernel that handles plugin registration, lifecycle management and inter-plugin communication. Business logic, AI features and external integrations are all added as plugins, each with its own namespace and route prefix, without modifying the kernel. The platform is aimed at developers who want to start from an organized foundation rather than build one.

Microkernel Architecture and Plugin Mechanics

Weave's architecture separates a minimal core kernel from an extensible plugin layer. The kernel handles routing, configuration loading, logging, security and fundamental runtime services. Every plugin implements the same Plugin interface: this standardizes lifecycle registration and gives the kernel a consistent way to initialize, suspend and shut down each component. Plugins register their own routes under their own namespaces, so a new AI feature can be added without touching any existing route table. The plugin manager performs dependency resolution and conflict detection before loading, which means plugins that declare dependencies on other plugins will refuse to load if those dependencies are absent. Hot-plugging is listed as a design goal: the README describes plugins being dynamically loaded and unloaded at runtime without restarting the system, though the README does not document the specific API for triggering this at runtime.

On top of the plugin layer, Weave uses a four-tier service hierarchy: an interface layer for HTTP routing and controllers, a business layer for core logic and plugins, a data layer for storage access and an infrastructure layer for logging, configuration and security. The separation is meant to keep request handling logic isolated from persistence code.

AI Stack: LLM, Chat, RAG and Agents

The repository's go.mod reveals one concrete AI dependency: github.com/cloudwego/eino-ext/components/model/ollama for local LLM inference via Ollama. The README describes an AI development stack covering LLM integration, AIChat (structured conversational interfaces), RAG (retrieval-augmented generation) and Agent (autonomous task execution), with a stated goal of providing standardized interfaces so developers do not need to implement lower-level AI plumbing themselves. The Bleve full-text search library (blevesearch/bleve_index_api and related packages) appears in go.mod, suggesting on-device document indexing for the RAG component. Beyond the Ollama model adapter and Bleve, the README does not detail which external AI APIs are supported or how the Agent abstraction handles multi-step task execution.

Building and Running Weave

Weave requires Go 1.26.4, as declared in go.mod. The Makefile provides the main developer commands. To compile the binary:

make build

This runs go build -o weave main.go. To run the application directly without compiling:

make run

The application starts on port 8081 by default, configurable through the SERVER_PORT environment variable. Weave uses GORM with drivers for MySQL, PostgreSQL and SQLite (via glebarez/sqlite for a CGo-free option). Database connection is configured through environment variables: DB_HOST, DB_PORT, DB_USERNAME, DB_PASSWORD and DB_NAME. JWT-based authentication is built in, controlled by JWT_SECRET, JWT_ACCESS_TOKEN_EXPIRY and JWT_REFRESH_TOKEN_EXPIRY. A Dockerfile ships with the repository using a two-stage build: a golang:1.23.4-alpine builder stage and an alpine:3.18 runtime stage that runs the binary as a non-root weave user.

Multi-Instance Deployment with Docker Compose

The docker-compose.yaml runs three Weave application instances (weave-1, weave-2, weave-3) behind an Nginx load balancer. Nginx listens on port 80 for HTTP and port 8084 for the load balancer entry. Each application instance exposes its own port (8081, 8082, 8083) and shares a common MySQL database, Redis and Prometheus monitoring. The Compose file defines named Docker volumes for MySQL data, logs, Prometheus metrics, Grafana dashboards and PostgreSQL data. Environment-variable overrides for DB_PASSWORD and JWT_SECRET use default fallback values in the Compose file, meaning production deployments must override these explicitly. The setup demonstrates how Weave is intended to run in a horizontally scaled configuration, though the Compose file hardcodes the GOPROXY to https://goproxy.cn, which targets the Chinese Go module mirror and may fail for developers outside that network.

Limitations and Licensing Gap

The AI component documentation in the README is more descriptive than instructional. The README outlines what the AI stack is intended to do (LLM, RAG, Agent, Chat), but does not include a worked example showing how to call the LLM interface, configure a RAG pipeline or define an agent workflow. Developers must read the plugins/ and services/ source directories to understand actual usage. The GOPROXY setting in the Dockerfile points to https://goproxy.cn, which will time out for builds outside China unless overridden. The repository also carries no open source license: the license field in the repository metadata is listed as unknown. Under default copyright, the code cannot be copied or distributed without explicit permission from the author, which makes production adoption risky without clarification.

Editorial conclusion

Backend developers building Go services that need AI capabilities wired into a structured plugin system will find Weave provides a defined architecture from day one. Teams whose AI use is limited to a single LLM call in an existing service do not need a full platform. The repository has no open source license listed, which means the default copyright applies: using or distributing the code in production requires checking with the author before proceeding. The last push to the repository was on 2026-07-15.

Frequently asked questions

Official sources

1. Issues
2. liaotxcn/Weave on GitHub
3. Project website
4. README