Ariadne: An Automated Technical Documentation Maintenance System Using Large Language Models

Ariadne is a connector-oriented system for automated maintenance of technical documentation after software changes, designed to address the pain point of disconnect between code changes and document updates. It implements an end-to-end workflow from code changes to document updates via a FastAPI backend, PostgreSQL persistence, and a human-machine collaborative review process. By integrating large language model capabilities to generate document update proposals, it ensures that documentation evolves in sync with code.

In software development, the disconnect between code changes and document updates is a long-standing problem: after developers modify APIs, configurations, or refactor modules, documentation is often delayed or missing, leading to user confusion and increased maintenance costs. Traditional manual update processes are time-consuming and error-prone, and document timeliness has become a bottleneck in agile development. To address this pain point, Ariadne introduces large language model capabilities to automatically generate document update proposals and ensure quality through human review, achieving synchronization between documentation and code.

System Architecture

Ariadne adopts a connector-oriented design, with pluggable connectors at its core to interface with document storage (e.g., GitHub, Confluence) and code change sources. Core entities include Workspace, Project, Documentation Target, Source Event, Proposal, and Document Revision. The layered design adapts to projects of different scales.

Technology Stack

The backend uses the FastAPI framework (asynchronous processing + OpenAPI support). The persistence layer uses PostgreSQL + SQLAlchemy ORM + Alembic migrations. Containerized deployment simplifies environment setup via docker-compose. The current demo version features a deterministic workflow and does not fully integrate large language models; a progressive development strategy is used to verify the architecture's rationality.

Ariadne's workflow embodies the concept of human-machine collaboration:

1. A developer triggers a source event (e.g., code submission), and the system creates a source event record;
2. The processing endpoint is called to analyze the event and generate a document update proposal;
3. The proposal enters a pending review state, waiting for human review;
4. If the reviewer accepts it, the system automatically writes to the target document and creates a revision record; if rejected, the proposal record is retained without modifying the document. This design balances automation efficiency and human quality control.

Current Limitations

Unimplemented features of the project include: React frontend interface, shadcn/ui component library integration, production-level authentication and permission system, real GitHub/GitLab/Confluence connectors, OpenAI API integration, advanced search and embedding, background task queue, and proposal timeliness detection.

Future Directions

Key priorities include advancing the development of real connectors and integration with large language models, improving the frontend interface to lower the barrier to use, gradually implementing uncompleted features, and enhancing the system's practical value.

Ariadne is an example of the combination of academia and engineering; transparently displaying limitations is beneficial for long-term development. Its human-machine collaboration model provides a feasible reference for AI-assisted documentation maintenance (document updates require high accuracy, and incorrect documents are more misleading). The code structure and data model are valuable references for developers exploring AI-assisted documentation maintenance, and the demo version can serve as a basic template for connector architecture and approval workflows.