Product Paper

Knixus RAG and MCP Server

knix-doc

Your AI agents' enterprise brain. A production-grade knowledge server that delivers the right information, to the right agent, with exactly the right permissions — at every stage of your development lifecycle.

Get in Touch See Architecture

Multi-Tenant

Full tenant isolation at every layer

Semantic Search

Vector + full-text hybrid retrieval

Redmine Native

Complete issue tracker integration

Live Permissions

Per-agent control, no redeploy needed

Administration

Governance Without Compromise

The web administration panel gives every team complete, code-free control over AI access. Define tenants, assign tool permissions, and manage RAG collection access from a clean interface — with changes taking effect immediately.

Tenant Isolation Every tenant operates in a fully namespaced environment. Documents, collections, and permissions are strictly scoped — no cross-tenant data leakage, by design.

Real-Time Permission Switches Enable or disable entire tool groups for any tenant with a single click. No server restart, no config file editing — permissions propagate instantly across all active agent sessions.

Controlled Collection Sharing Share document collections across tenants with explicit access grants. A shared knowledge base can serve multiple teams while each team's private documents remain completely isolated.

Full Operational Visibility View, edit, and manage every document in the system from the admin panel. Inline Markdown rendering, chunk inspection, and metadata editing — all in one place.

knix-doc · Admin Panel · Tool Permissions

Doc Tools Permissions — Tenant: dev-team-alpha

doc_tools ✓ Enabled

redmine_tools ✓ Enabled

mcp_loc_run_tools Restricted

mcp_loc_web_tools ✓ Enabled

mastodon_tools — Disabled

MCP Loc Permissions — Tenant: qa-agent

mcp_loc_run_tools ✓ Full Access

mcp_loc_git_tools ✓ Enabled

Knowledge Retrieval

Search That Understands Intent, Not Just Keywords

Keyword search fails when developers phrase questions differently from how documentation was written. knix-doc's hybrid RAG engine combines exact full-text precision with semantic vector search — understanding the meaning behind every query.

Hybrid Retrieval: Exact + Semantic Full-text search for precision lookups and 384-dimensional sentence embeddings via pgvector for conceptual similarity — both available as dedicated MCP tools that agents can choose from based on context.

CPU-Only ONNX Inference Sentence-transformer embeddings run entirely on ONNX Runtime — no PyTorch, no GPU required. Production-ready on any standard server with zero heavy ML dependencies.

Automatic Chunking with Overlap Long documents are automatically split into configurable chunks with adjustable overlap, ensuring no context is lost at chunk boundaries. Re-chunking happens transparently on edit.

Multi-Collection Tenant Search Search within a specific collection or across all tenant-accessible collections simultaneously. Shared collections from other tenants are transparently included based on access grants.

doc_semantic_search · MCP Tool Call

collection: engineering-docs · top_k: 3 · mode: semantic

0.941

Payment Gateway — Retry Policy (v2.3)

After a gateway timeout, the system waits 30s before the first retry. Exponential backoff applies with a cap of 4 attempts...

0.887

Transaction Error Handling Guide

Timeout conditions (HTTP 504, connection reset) are classified as retriable. See RETRY_CONFIG for environment-specific...

0.823

Ops Runbook — Payment Incidents

Gateway timeout incidents: check retry queue depth in Grafana dashboard. If backlog > 500, escalate to payment team...

pgvector ONNX Runtime all-MiniLM-L6-v2

Project Integration

Your Issue Tracker, Now AI-Accessible

Every issue, comment, status update, and workflow transition in your Redmine instance becomes accessible to AI agents via clean MCP tools — with zero integration effort and without touching your existing Redmine setup.

Full CRUD via MCP Tools Create issues, update status, add comments, assign developers, change priorities — every Redmine operation available as a structured MCP tool call from any AI coding session.

OpenAPI-Driven Tool Generation Redmine tools are generated from the OpenAPI specification, ensuring the interface is always consistent with the actual API — no manual maintenance, no drift between tools and reality.

Knowledge-to-Issue Traceability Documents stored in knix-doc can reference Redmine issue IDs directly in metadata. Agents searching for implementation details automatically surface the originating issues for full context.

Closes the PM-Developer Loop PM agents can create and prioritize issues. Developer agents can query them, implement against them, and update their status — all without leaving the AI coding environment.

AI-Driven Development Workflow

PM Agent

Creates issue #472: "Implement payment retry"

Dev Agent

Queries docs + reads issue context

Implements

Writes code, updates issue status

QA Agent

Runs tests, closes issue

Available MCP Tools

redmine_create_issue redmine_update_issue redmine_list_issues redmine_add_comment redmine_assign redmine_update_status

Multi-Agent Orchestration

The Right Tool for the Right Agent, in Real Time

Multi-agent IDEs like Opencode run simultaneous specialist agents — a coder, a reviewer, a PM, a QA engineer. knix-doc's tenant-based permission matrix was built precisely for this: define what each role can access, change it live, no redeployment ever needed.

Per-Tenant, Per-Group Permission Matrix Independently control access to doc_tools, redmine_tools, mastodon_tools, mcp_loc_git_tools, mcp_loc_run_tools, and mcp_loc_web_tools for each tenant independently.

Instant Effect, Zero Downtime Permissions are validated on every tool call. Flip a switch in the admin panel and the change is enforced on the very next MCP request — no agent restart, no session invalidation.

Opencode and Multi-Agent IDE Compatible Each agent role gets its own tenant ID. Map Opencode's PM, developer, and reviewer roles to separate knix-doc tenants with precisely scoped permissions — clean separation, zero configuration leakage.

CI/CD Pipeline Agent Support Issue a restricted CI/CD tenant with read-only doc access and specific mcp-loc tools for automated validation pipelines. Revoke access instantly if a pipeline misbehaves.

Tenant Permission Matrix — Example Configuration

Tool Group	PM	Dev	QA	Reviewer
doc_tools (read)	✓	✓	✓	✓
doc_tools (write)	✓	✓	—	—
redmine_tools	✓	✓	Read	Comment
mcp_loc_run_tools	—	✓	✓	—
mcp_loc_git_tools	—	✓	✓	Read
mcp_loc_web_tools	—	✓	✓	✓

All values configurable live from the admin panel — no server restart required.

Code Intelligence

Code Quality as a First-Class Citizen

Most MCP servers stop at knowledge retrieval. mcp-loc goes further: it gives AI agents the ability to run code, validate results, and verify quality — directly from the same permission-controlled environment. Not just writing code, but knowing it works.

Controlled Shell Execution Run tests, linters, build scripts, and validation commands through permission-gated shell tools. Define exactly which commands agents can execute — enterprise QA pipelines with AI-native control.

Git-Integrated Development Flow Agents can stage, commit, diff, and inspect git history through mcp-loc's git tools — making it possible to build truly autonomous development loops: write → test → commit → report.

Web Research Within the Workflow Research-driven development: agents can fetch documentation, query APIs, and search the web without leaving the coding session — bringing external context directly into implementation decisions.

Extensible by Design mcp-loc's tool library is actively growing. The same permission framework that controls existing tools automatically covers new ones — as capabilities expand, governance keeps pace.

mcp-loc — Enterprise QA Loop

Agent executes test suite

                            $ pytest tests/ -v --tb=short

                            PASSED tests/test_payment.py::test_retry [42ms]

                            PASSED tests/test_payment.py::test_timeout [38ms]

                            WARN  coverage: 78.4% (threshold: 80%)

                            → Agent flags coverage gap to Redmine #472

Agent commits after validation

                            $ git diff --stat HEAD

                            src/payment/retry.py | 24 ++++--

                            $ git commit -m "fix: payment retry backoff #472"

                            [main a3f9c1b] fix: payment retry backoff #472

Shell Exec Git Tools Web Fetch Permission-Gated

Enterprise Readiness

Define Your Team. Deploy in Minutes.

A modern software company's development process involves many roles operating at different stages. knix-doc's tenant + permission model maps directly onto these roles, letting you deploy specialized AI agents at every phase of the development lifecycle — without custom integrations or complex orchestration.

Project Manager Agent

Strategic oversight & issue governance

Creates and prioritizes Redmine issues, monitors project documentation, tracks deliverables, and keeps the knowledge base aligned with project goals. Bridges business requirements and technical execution.

redmine: full doc_tools: read+write no run_tools

Developer Agent

Implementation & knowledge generation

Full access to documentation search and storage, Redmine issue updates, git operations, and shell execution. Writes implementation docs back to knix-doc after coding — closing the knowledge loop automatically.

doc_tools: full redmine: write mcp_loc: full

QA Agent

Automated quality enforcement

Runs test suites, validates coverage thresholds, inspects git diffs, and reports results directly to Redmine issues. Reads documentation to verify implementations match specifications — zero manual handoff.

run_tools: full git_tools: full redmine: comment doc: read

Analyst Agent

Cross-domain knowledge synthesis

Deep semantic search across multiple collections, synthesizing technical documentation, issue histories, and external research into structured insights. Supports decision-making at every level of the organization.

doc_tools: read web_tools: full redmine: read

Code Reviewer Agent

Standards & consistency guardian

Reviews git diffs against architectural documentation stored in knix-doc, checks coding standards, verifies that implementations match specs, and posts structured review comments to Redmine.

doc: read git: read redmine: comment

Your Custom Role

Unlimited configuration

Any combination of tools, any scope of access. Define roles that match your organization's actual workflow — not a template someone else designed.

System Design

Architecture Overview

A clean, production-grade stack built for reliability, tenant isolation, and zero heavy ML dependencies.

AI Clients

Knixus Agents Qwen · Zen · Max

Multiagent IDE

VS Code / Cursor AI Extensions

CI/CD Pipelines Automated Agents

↓

MCP Protocol (HTTP/SSE) · X-Doc-Tenant-ID header routing

knix-doc Server — FastMCP + FastAPI

Doc Tools RAG / CRUD / Search

Redmine Tools Issue / Project Mgmt

mcp-loc Tools Shell / Git / Web

REST API File Upload / Admin

Permission Layer Tenant-scoped, real-time enforcement

Model Manager ONNX Runtime · CPU-only embeddings

Admin Panel Flask · Tenant / Doc / Permission UI

↓

asyncpg connection pool · JSONB + VECTOR columns

Data Layer

PostgreSQL Documents · Tenants · Collections

pgvector VECTOR(384) semantic index

Redmine API External · OpenAPI spec

Built With

Python 3.11+ FastMCP + FastAPI PostgreSQL + pgvector ONNX Runtime Flask Admin asyncpg Alembic Migrations

Get Started

Ready to Build Your AI-Native
Development Environment?

knix-doc is designed for teams that take AI-assisted development seriously. Give your agents the knowledge layer, the governance controls, and the workflow integrations they need to deliver real results.