AOCI CODE MCP Server

MCP文档知识

提供方 aoci-spec

文档知识 未标注 OAuth 授权 社区 / 第三方 ClaudeCursorVS CodeGemini CLI

Local MCP server and CLI that keeps a Git-versioned, model-written index of a codebase and its database schema, so coding agents start each task with the whole system in view.

一句话选型结论

按资料字段整理

AOCI CODE MCP Server 属于文档知识类 MCP 服务器,传输方式未标注,OAuth 授权,可直接接入 Claude、Cursor、VS Code 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式未标注 鉴权OAuth 授权 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 9 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量9暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

mcpcodebaseclaude code

安装与配置

未标注 OAuth 授权
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后客户端会列出约 9 个工具,随便调一个只读工具确认能返回结果。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 资料标注 9 个工具,职责相对集中,接入后不容易误操作。
  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
AOCI CODE MCP Server当前 9 未标注 未标注 无 2026-11-20
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方aoci-spec上游标注的维护方 aoci-spec
分类文档知识本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式OAuth 授权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · go本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验2026-11-20上游最后核验时间

详细介绍

72.0 KB
来自项目仓库与上游目录的原文,未做删改

AOCI-CODE

A persistent, Git-versioned map of your entire codebase — written by your coding agent, governed by a local MCP server. Agents read it once and know the system, instead of re-reading the repo on every task.

🇺🇸 English | 🇨🇳 简体中文

https://github.com/user-attachments/assets/31636873-3e05-401f-849a-1f1ea87cd0a4

What it does

Build large systems without losing the plot. In Codex, Claude Code, Cursor, OpenCode, and similar agents, your agent starts every task already knowing the whole system: what each file is for, what it depends on, and what must not break. It stops searching and re-reading the codebase for every request. People who are not professional developers can keep iterating on their own systems; professional developers can hand the whole system to an agent and keep their attention on architecture and design.

Take over an existing system in one step. Point the agent at an existing codebase of up to about 500,000 lines and ask it to build the index. It reports how well it knows each area, then picks up development from there. The practical limit is the size of the index, not the line count: a 700,000-line commercial system is developed this way today, with an index of about 300K tokens.

Change people, agents, or conversations without starting over. The index lives in the repository next to the code and is versioned by Git. When a project changes hands, switches agents, or opens a new conversation, one read of the index picks up where things left off.

After the first index, maintenance is automatic. The MCP server detects code changes and issues the entries that need updating. The agent fills them in as it finishes each task, so the index matches the current code and you never stop to maintain it.

What it looks like

One line per file, written by the model from the actual source. This is a real entry from this repository's own index:```text
atomic.go[CG9L]: F:Provides durable replace CAS, create CAS, atomic writes, and no-clobber recovery moves | R:code:internal/fs/atomic_exchange_linux.go,code:internal/fs/atomic_exchange_windows.go,code:internal/fs/lock.go | A:AtomicWrite,AtomicWriteCAS,AtomicCreateCAS,AtomicMoveCAS | S:Native publication never degrades to an overwriting rename; on a race, unsafe type, or unverifiable bytes, preserve third-party state


**F** is what the file is responsible for, **R** is what you have to read along with it, **A** is what callers depend on, and **S** is what you cannot infer from the code but must not get wrong. The tag `[CG9L]` places the file by layer, domain, importance, and size. A few hundred lines like this cover a whole system, and an agent can read them in one pass. The entry format explains each field.

## How is this different from CodeGraph?

- **CodeGraph** parses your code into a graph of symbols and calls. When the agent asks a question, it returns the exact source and call paths. It is a precise lookup tool for the task at hand.
- **AOCI-CODE** has the model write one line per file and table: what it is for, what it connects to, and what must not break. The agent reads the whole index first, so it knows the system before the task starts. The index lives in Git and is kept in step with the code.
- Use both: the index to know the system, CodeGraph to fetch the exact code while working.

The full comparison covers RAG, LSP, and repo maps too.

## What to expect

**The first index takes a while.** The agent reads every managed file and writes one entry per file: about an hour per 200,000 lines of code, depending on the model and the agent's speed. It runs in batches and resumes where it stopped if interrupted.

**Have a database? Index it too.** MySQL and PostgreSQL are supported, and openGauss 6.0.5 with constraints. MySQL means 5.7.6 and later; MariaDB is not supported. Build the code index first, then the database index. With code and table-level knowledge delivered together, the agent understands the system more completely.

**Local only: read-only on your system, no Internet, no stored credentials.** AOCI-CODE reads your source code and database table structures, never business data. It writes its index files and its own state inside the project directory, plus the status page's registration in your user cache directory. It never reaches the Internet and uploads nothing: the only connections it opens are to the database you declare, for catalog metadata, and to its own loopback status page. Database credentials are referenced by environment-variable name and never stored. The index text is written locally by your own agent through the model channel you already use; AOCI-CODE adds no new data exit.

## Quick start

Give your agent the following instruction to download AOCI-CODE and wire it up. After you restart the agent, send the second instruction to build the index.```text
AOCI-CODE project: https://github.com/aoci-spec/aoci-code

Download the newest release package, pre-releases included, for this operating system and
CPU architecture from https://github.com/aoci-spec/aoci-code/releases, and follow the
installation instructions on the Release page to verify it. If no compatible release
package exists, or if I explicitly request the latest source, build it from the official
repository.

After extracting the package, place aoci (aoci.exe on Windows) at a stable absolute path.
Then use that absolute path to do the following for my project:

1. Run init to initialize AOCI and integrate MCP for the current host; if this host does
   not write project configuration (Cursor, for example), give me the configuration I
   need to paste myself
2. Run scan

   scan takes its file inventory from Git, so do not add the cognition assets
   init writes (aoci.txt, aoci.meta.txt, aoci.code.txt, AGENTS.md) to .gitignore
   or .git/info/exclude — an ignored asset is silently skipped and the index
   cannot be built. Leave the host-config ignore init writes for itself as it is.

3. Tell me to restart the agent so the newly written MCP server takes effect

Stop after those three steps and do not build the index yet — I will tell you to continue
after the restart.

After restarting the agent, send this one:```text
First confirm the AOCI MCP server is connected, then build the AOCI index for this project. When it is complete, give me the AOCI panel link.


The agent starts the panel in the background with `aoci ui --detach --json` and hands you the link. AOCI panel covers what it shows and its other commands.

Why the restart: the index is written through AOCI's MCP tools, and the session that ran `init` has not loaded the MCP server `init` just wrote. A host that loads MCP servers dynamically may not need a restart; Host integration explains how to tell.

If your project has a database (PostgreSQL and MySQL are supported, plus constrained openGauss 6.0.5), index it as well. Declare the source as described under Database Cognition, provide the connection-string environment variable in the host environment (AOCI stores no credentials), then send:```text
Build the AOCI database index for this project.

If the context has been compacted, or you want the agent to rebuild its picture of the system, send this:```text
Using only AOCI, establish whole-framework cognition of this project, tell me your mastery of each area as a percentage, and whether you can take over development.


## How it works

**AOCI (AI-Oriented Cognition Infrastructure)** is the method and protocol: a layer between coding agents and software systems. Models reason, agents plan and execute, and AOCI keeps an up-to-date description of the system, covering code, configuration, tests, and database structure, for agents to read before they act. **AOCI-CODE** is this project: the `aoci` CLI, the MCP server, and the index they maintain.

AOCI-CODE distills what actually matters for understanding and changing a system into a dense, plain-text index that combines symbols and meaning. When model context is limited, an agent reads the index first, gets most of the project's key information in one pass, and then starts the task. That cuts repeated searching and re-learning, and it carries understanding across tasks and sessions.

- **Not a one-time summary.** The index evolves with the system and stays in the project, where you can diff, review, version, and roll it back with Git.
- **More than "where files are."** It records responsibilities, strong relationships, public contracts, transaction boundaries, compatibility constraints, and other things that are hard to infer from code structure.
- **Portable.** The index is stored with the project, not tied to a model, an agent, or a session. While it is aligned with the code, any agent and any later session can reuse it without rebuilding its understanding from scratch.
- **Code and databases together.** The model can build a separate table-level index for database tables. Delivered together, the two give the agent a fuller picture of the system.

The index is a set of governed plain-text files stored with the project:

- **Root (`aoci.txt`)** declares what makes up the current index and is its activation entry point.
- **Meta (`aoci.meta.txt`)** holds the tag dictionary, the FRAS rules, and the authoring constraints.
- **Code (`aoci.code.txt`)** holds the model-authored entries for code and other repository assets.
- **Database (`aoci.database.txt`)** holds optional table-level entries when Database Cognition is enabled.

Root, Meta, and the participating object Volumes together form the Whole-Index. The workflow on top of them has three stages:

1. **Build the index under governance.** The model reads source code and accepted evidence. AOCI-CODE governs Managed Scope and the entries the model writes for every managed object with the `index` role.
2. **Read before acting.** The agent reads the project rules, the live guide, and the current Whole-Index, then checks source and other evidence for the task at hand.
3. **Maintain after verified change.** Once code and tests are stable, the project rules and the MCP workflow have the agent update the affected entries and bring the index back to `aligned`.

Because these files are plain text in the repository, Git versions them. While the index stays aligned with the current system version, any agent and any later session can read and reuse the same Whole-Index.

## Manual integration

Get AOCI-CODE from the canonical source or use a signed package from GitHub Releases. Before using a prebuilt binary, follow the basic, recommended, or full verification level in the installation guide, and report which level completed. Give this README and the verified binary's stable absolute path to a coding agent you trust, such as Codex, Claude Code, Cursor, or OpenCode. The agent can follow the in-project instructions to initialize AOCI, integrate MCP, and build the first index.

How long the first index takes depends on repository size. A normal integration is four steps: prepare the binary, have the agent or yourself initialize the target repository, ask the host to "build the index," and verify alignment. After that you do not need to end every request with "maintain the index." The project rules and the MCP workflow have the agent maintain the index incrementally whenever managed objects change.

### Requirements

- A verified release package or a checkout of the canonical AOCI-CODE source repository.
- For source builds only: the Go toolchain declared by `go.mod`, `make`, and the other tools the repository requires.
- A supported MCP host, such as Codex, Claude Code, Cursor, or OpenCode.
- Normal read and write access to the target repository.

AOCI-CODE integrates with the MCP host, not with a model-provider API. DeepSeek
and other models can use AOCI-CODE when the agent or host running them supports
standard stdio MCP and can follow the tool contract; a model name alone does not
establish compatibility.

The signed-package route and executable verification commands are in the installation guide. The source-build route is below.

### Current release: use a verified package or build from source

> [!IMPORTANT]
> AOCI-CODE v0.2.0-rc2 is the current release. It is Fair Source/source-available software under FSL-1.1-MIT; see LICENSE. Build from canonical source or use a signed package from the v0.2.0-rc2 GitHub Release after following the release verification procedure.

The signed Release binary identifies itself as `aoci version 0.2.0-rc2`. A
source build identifies the exact checkout instead and may report a development
version such as `v0.2.0-rc2-1-g` (plus `-dirty` when applicable),
together with its Git commit. These are different build inputs, not a version
conflict.

To download with GitHub CLI, authenticate first, then download the tagged
Release assets:```bash
gh auth login
gh release download v0.2.0-rc2 --repo aoci-spec/aoci-code

For an anonymous download, open the
v0.2.0-rc2 Release page
in a browser and download the archive and verification assets you need.

To build from source, clone the canonical repository, build the binary, and keep the resulting path stable:```bash
git clone https://github.com/aoci-spec/aoci-code.git
cd aoci-code
mkdir -p build
make build
./build/aoci --version


On Windows, build the same source in PowerShell:```powershell
git clone https://github.com/aoci-spec/aoci-code.git
Set-Location .\aoci-code
New-Item -ItemType Directory -Force .\build | Out-Null
make build
.\build\aoci.exe --version

Then give this README to an agent you already trust with the project and ask:```text
Read this AOCI-CODE README and use the built aoci binary at its stable absolute path
to initialize AOCI for the current project, integrate MCP, and run scan. Stop there and
tell me to restart the agent; I will ask you to build the index afterwards.


The agent should identify the project root, use a stable absolute path to the built binary, run the initialization that fits the current host, and tell you clearly when a host restart or real human approval is required. The binary can stay in the AOCI-CODE checkout or move to a shared tools directory, as long as the MCP configuration points at the correct absolute path.

### Manual initialization

To initialize AOCI yourself, run the following from the target repository root, or pass an explicit path through `--repo`:```bash
AOCI=/absolute/path/to/aoci-code/build/aoci
"$AOCI" --repo . init --locale en-US --agent codex
"$AOCI" --repo . scan

init writes the locale configuration, the managed AGENTS.md rules block, the Git boundaries, and an empty index skeleton. Configuration and prompting vary by host; see Host integration. It does not invent business meaning from filenames, directories, or an AST.

For a new repository, the first scan establishes the managed Baseline. For a project that already has a governed Baseline, adding, removing, or changing managed scope goes through the formal Scope Change workflow; scan --force is not a shortcut for redefining governance facts. --force also cannot erase unresolved drift, receipts, or recovery boundaries.

Windows PowerShell```powershell
$Aoci = (Resolve-Path "C:\path\to\aoci-code\build\aoci.exe").Path
& $Aoci --repo . init --locale en-US --agent codex
& $Aoci --repo . scan


Confirm that `$Aoci` points to a stable absolute path.

### Have the agent build the first index (important)

Once initialization and `scan` are done, check whether the agent session already exposes the AOCI tools; refresh or restart it if not. Then enter the following in the agent for the target project:```text
First confirm the AOCI MCP server is connected, then build the AOCI index for this project. When it is complete, give me the AOCI panel link.

The agent starts the panel in the background with aoci ui --detach --json and hands you the link. AOCI panel covers what it shows and its other commands.

The host reads the project's AOCI rules and live guide, inspects source code, tests, configuration, and relevant evidence, and then writes FRAS candidates for every managed object whose role is index. You do not need to orchestrate Plan, Stage, Check, Diff, CAS, or Apply yourself.

Once the first index is complete, send ordinary development requests as usual, for example:```text
Add priorities to tasks, including the frontend, backend, database, and test changes.


You do not need to append "maintain the AOCI index at the end." The project rules and MCP have the agent check for index changes once code and tests are stable, then update the affected entries through the formal workflow. When the project uses `automation.mode=auto`, AOCI-CODE interrupts you only when real human approval is required, an external action must be performed, recovery cannot be proven, a safety check fails, or a third-party concurrency conflict is found. Other automation modes follow their own runtime contracts.

### Verify alignment

After onboarding completes, run:```bash
"$AOCI" --repo . verify
"$AOCI" --repo . check

The index and the current managed source should converge back to aligned. If they do not, consult the live guide first; do not duplicate the internal state machine in a wrapper script:```bash
"$AOCI" --repo . index agent guide --agent codex --json


### Run basic diagnostics```bash
"$AOCI" --repo . capabilities
"$AOCI" --repo . doctor

To confirm which AOCI the host is actually connected to, read what the server reports about itself rather than what is on disk. In any aoci_overview check_only response or any aoci_maintain response, cognition_receipt.mcp_service_version is the running version and runtime_repository_root is the repository it governs. The matching binary path is the command in the project's .mcp.json or the equivalent host configuration: .codex/config.toml, opencode.json, or .cursor/mcp.json. Replacing bytes on disk does not change a running MCP process, so recheck against those facts after an upgrade or a rollback.

For a one-off walkthrough, use examples/minimal-repository in the repository.

Developers: build the AOCI-CODE CLI from source

If you are developing AOCI-CODE itself, run the fast quality gate during ordinary development and before a commit:```bash
make fast


Run the following when you need Full Confidence verification and an executable:```bash
make full
./build/aoci --version

make full is the Full Confidence gate and already includes make build. make check is only a compatibility alias for the same full gate, so there is no need to run both. Use make release-check for stable-release rehearsals. If you only need a direct build, run:```bash
mkdir -p build
CGO_ENABLED=0 go build -o build/aoci ./cmd/aoci


The AOCI-CODE CLI is a CGO-free, single-binary Go program. The `make build` target uses Go's native executable suffix: `build/aoci` on Linux and macOS, and `build/aoci.exe` on Windows. Before a release or delivery, rely on the actual binary's `--version` and `capabilities` output and on the formal Release Manifest, not on a version string in the README.

## What appears after initialization

A typical repository contains these index files:```text
aoci.txt                    Root: declares the current CognitionSet and participating Volumes
aoci.meta.txt               Meta: tag dictionary, FRAS rules, and authoring constraints
aoci.code.txt               Code: model-authored entries for code and repository assets
aoci.database.txt           Database: optional table-level entries; absent by default
.aoci/
├── config.json             Team policy, Locale, Scope, and budgets
├── baseline.json           Governed Baseline for source, index, and database bindings
├── curation.json           Optional file-level include/exclude decisions
└── ...                     Drafts, Ledger, transactions, and recovery evidence; normally not committed to Git

Initializing a new project creates the Root, Meta, and an empty Code Volume; Database is absent by default. AOCI-CODE does not generate business meaning for the repository or the database on its own.

aoci init --agent additionally writes host integration configuration
(.mcp.json, .claude/settings.json, .codex/config.toml, or opencode.json)
whose command and repository paths are machine-bound absolute paths. Add those
files to the repository's .gitignore and do not commit them: a committed copy
breaks on every other machine, and because the installers detect an existing
entry by key presence, re-running init there silently keeps the broken paths.

How a development task runs

The two diagrams below show the workflow as you experience it, not AOCI's internal implementation.

New project: build a simple system first, then bring in AOCI```mermaid

flowchart TD
I["The user proposes a product idea and requirements"] --> S["Use the agent's existing capabilities to build a simple new system"]
S --> Q["Integrate AOCI MCP"]
Q --> V["The agent builds the Whole-Index and verifies aligned"]
V --> N["The user continues with ordinary development requests"]
N --> M["The agent completes code, tests, and incremental index maintenance"]
M --> N


*A new system does not need AOCI-CODE from the first line of code. Build a prototype with the agent's existing capabilities first; roughly 10,000–30,000 lines is a good point to bring it in (not a hard threshold). Teams that want cross-session continuity earlier can integrate sooner.*

### Existing project: index the repository, then iterate```mermaid
flowchart TD
    R["Existing repository, tests, configuration, and optional Schema"] --> B["Build AOCI-CODE from canonical source<br/>Request index generation"]
    B --> E["The agent inspects the existing system and writes the first index"]
    E --> V["The final batch's terminal proof reports aligned"]
    V --> T["The user submits an ordinary development task"]
    T --> C["The agent modifies code and runs quality checks"]
    C --> U["MCP guides the agent through index maintenance"]
    U --> G["The index and the current system return to aligned"]
    G --> T

After the first index is complete, both flows work the same way day to day: you describe the business or engineering requirement; the agent combines the Whole-Index with current evidence, does the development and verification, and updates the changed objects through MCP as it closes the task. You do not need to learn the internal Plan, Stage, Diff, CAS, or Baseline commands, or repeat the maintenance requirement in every prompt.

If a complete batch is rejected before any formal write begins, the index is unchanged. If the workflow is interrupted after formal writes begin, the system keeps the immutable intent, the write evidence, and the recovery state, then either resumes from a provable postimage or rolls back to the exact preimage. A third-party byte conflict fails closed; AOCI-CODE never overwrites an external modification to "finish the write."

The final state is always one of applied, repair_required, or stopped. stopped is not success, and it does not necessarily mean nothing was written; inspect failed_step, the formal-write evidence, and the recovery action the guide returns.

Who does what: the model and AOCI-CODE

The model owns meaning

The host model reads source code, tests, configuration, documentation, and whatever evidence it needs, then decides:

  • what an object is actually responsible for;
  • which files, modules, or database objects are strong relationships that must be considered to change it safely;
  • which APIs, commands, formats, or observable contracts it exposes;
  • which transaction, authorization, concurrency, caching, deployment, compatibility, or historical constraints cannot be inferred from ordinary structure alone.

AOCI-CODE does not assemble FRAS from filenames, paths, extensions, ASTs, or templates, and it does not silently rewrite what the model wrote.

AOCI-CODE owns governance

AOCI-CODE is responsible for:

  1. establishing Safe Inventory, Managed Scope, and the current Baseline;
  2. delivering the current Whole-Index and confirming its identity;
  3. generating a deterministic plan, target set, and source SHA-256 values;
  4. validating candidate structure, the tag dictionary, relationship identities, scope, ownership, budgets, and affected range;
  5. preserving the binding among check, diff, and review content;
  6. committing a complete batch with cross-process locks, CAS, and atomic writes;
  7. advancing the Baseline, appending the ledger, and preserving recovery evidence after a post-write failure;
  8. reading the governance verdict the final batch carries as its terminal proof;
  9. deriving Lineage, Relations, Impact, Snapshot, and Evolution observations from authoritative assets without creating a second source of truth.

All-green machine results mean only that the encoded structural and governance contracts hold; they do not mean that every statement the model wrote is correct.

How the index is organized

An AOCI index has two layers: the index rules and the index entries. The product supports two physical layouts, and they are not one file format.

Volumes v1 layout

A Volumes project separates responsibilities:

  • aoci.txt is only the Root. It declares the Volumes that take part in the current CognitionSet.
  • aoci.meta.txt holds Meta: the tag dictionary, the FRAS rules, budgets, and the authoring contract.
  • aoci.code.txt holds the entries for code objects.
  • aoci.database.txt holds the entries for database objects when Database Cognition is enabled.

Code and Database Volumes share the same FRAS line structure, but they have independent object identities, evidence bindings, ownership, and lifecycles. Root, Meta, and the object Volumes together form the Whole-Index; reading only the aoci.txt Root is not enough to claim you have read the whole system.

Think of it as a map:

  • The index rules are the map's legend and coordinate system.
  • The index entries are the markers that describe each location.
  • Root is the catalog and version entry point for the current map set.
  • A Volume is a separate sheet governed by the same protocol but with its own evidence source and lifecycle.

What the index header looks like

Root and Meta each open with machine-read header lines. This is what aoci init writes for a new en-US project named my-service, starting with the Root, which is the activation entry point:```text

AOCI-ROOT-MANIFEST: 1

Format-Version: cognition-volumes/v1

Locale: en-US

Project: my-service

Global-Invariants: -

Volume: id=meta kind=meta path=aoci.meta.txt format=meta-v1 depends=- state=enabled

Volume: id=code kind=code path=aoci.code.txt format=object-fras-v2 depends=meta state=enabled


Each `#Volume:` line declares one participating Volume with its identity, kind, path, format, dependency, and activation state. A Volume that is not declared here is not part of the current CognitionSet, whatever else the working tree contains. Enabling Database Cognition adds one more line, `#Volume: id=database kind=database path=aoci.database.txt format=table-fras-v2 depends=meta state=enabled`.

Meta then opens with the rules that govern every entry:```text
#AOCI-META-VOLUME: 1
#Object-Protocol: repository-cognition-object/v2
#FRAS-Discipline: 2
#FRAS-v2-Limits-Authority: machine-contract
#S-Admission: non-inferable-and-error-preventing
#S quota: C9-8≤600 C7-4≤200 C3-1≤50
#Object-Kinds: code=file database=table

#FRAS-v2-Limits-Authority: machine-contract is the load-bearing line: the field limits belong to the binary, not to this text, so a project cannot widen them by editing its own Meta. #S-Admission and #S quota govern the S field specifically: what may be recorded there at all, and how many characters each importance band may spend. The tag dictionary follows immediately after these lines; it is shown in full further below.

The Code Volume opens with a single line, #AOCI-CODE-VOLUME: 1, and everything after it is directory sections and entries.

These are the values a new project starts from, not fixed protocol constants. Each repository's own Root and Meta are authoritative afterwards: an older project may carry a custom tag dictionary, and a project initialized with --locale zh-CN writes #Locale: zh-CN and localizes the #S quota: key accordingly.

What the index rules define

Rule Purpose
Tag dictionary Compact tags for an object's architectural layer, functional domain, importance, technical characteristics, and size
FRAS fields How each entry records responsibility, strong relationships, public interfaces, and key constraints
Relationship rules How relationships between objects are referenced, so descriptions are neither ambiguous nor unverifiable
Scope and ownership Which objects enter the index with the index role and which Volume owns each object
Length and budgets Information density, so source code or an ordinary summary is not copied into the index
Validation rules The structural and governance conditions a candidate entry must satisfy before it enters the formal index

In Volumes v1, the project's Meta Volume stores these rules; in the Legacy layout, they live in the monolithic header. Projects may use different tag dictionaries, while the basic FRAS structure stays the same.

This README only explains how to read these rules. For the concrete, executable rules, defer to the current project's Meta or Legacy header, the AOCI guide, and the formal specification.

What one entry records (FRAS)

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
AOCI CODE MCP Server 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

AOCI CODE MCP Server 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

AOCI CODE MCP Server 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

AOCI CODE MCP Server 需要 API Key 吗?

资料标注需要OAuth 授权认证,使用前准备好对应凭据,并按最小权限配置。

AOCI CODE MCP Server 支持哪些客户端?

资料标注支持 Claude、Cursor、VS Code、Gemini CLI、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

AOCI CODE MCP Server 能提供哪些能力?

资料显示约 9 个工具;能力标签包括 mcp、codebase、claude code、codex、cursor、golang。具体工具清单以官方文档为准。

AOCI CODE MCP Server 需要什么运行环境?

运行时为 go。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-11-20。