DPR MCP AI Document Collaboration Platform

Este proyecto es una plataforma local de colaboración de documentos, respaldada por Git, en la que las personas y los agentes de IA pueden trabajar de forma segura en documentos compartidos.

Combina:

• Servidor Model Context Protocol

• Cliente MCP real sobre stdio

• Panel de React

• Agentes basados en LangGraph

• Control de versiones respaldado por Git

• Espacios de trabajo aislados

• Solicitudes de cambio

• Revisión y fusión humanas

• Detección de conflictos

• Propuestas de resolución de conflictos

• Seguimiento de la procedencia

La idea principal:

AI agents can write and review documents, but they cannot silently overwrite main.
Every edit becomes a versioned, reviewable, traceable Change Request.

Por qué existe este proyecto

La edición normal de documentos con IA es arriesgada porque un agente puede sobrescribir directamente un archivo, perder el historial, mezclar las ediciones de varios usuarios o hacer que no quede claro quién cambió qué y por qué.

Este proyecto soluciona esto colocando a los agentes de IA detrás de un protocolo de colaboración controlado:

Agent -> MCP Client -> MCP Server -> Controlled Tools -> Git + SQLite

El agente no modifica directamente el repositorio canónico de documentos. Crea un espacio de trabajo aislado, edita archivos en él, abre una solicitud de cambio y espera a la revisión humana.

Related MCP server: agentsync

Arquitectura

Arquitectura completa del proyecto:

Arquitectura de agentes de la Fase 2:

Flujo de alto nivel:

React Dashboard / External MCP Client
        |
        v
Dashboard API
        |
        v
LangGraph Agents
        |
        v
DPRMCPClient
        |
        v
MCP stdio
        |
        v
DPR MCP Server
        |
        v
MCP Tools
        |
        v
DPR Services
        |
        v
Git Repositories + Isolated Workspaces + SQLite Metadata

Componentes principales

Servidor MCP

El servidor MCP es la interfaz de backend controlada. Expone herramientas seguras para la colaboración en documentos.

Punto de entrada:

src/dpr_mcp/server.py

Herramientas importantes:

• create_project

• create_workspace

• read_project_file

• read_change_file

• create_file

• edit_file

• create_change

• review_change

• approve_change

• merge_change

• get_diff

• get_file_patch

• get_conflicts

• propose_conflict_resolution

• apply_conflict_resolution

• rollback_change

• get_provenance

Ejecución directa:

python -m dpr_mcp.server

El servidor habla MCP a través de stdio. Normalmente, un cliente se comunica con él; no se escribe manualmente en el proceso.

Cliente MCP real

El cliente MCP reutilizable está aquí:

src/dpr_mcp/mcp/client.py

Arranca o se conecta al servidor DPR MCP a través de stdio y llama a las herramientas por su nombre. Esta es la misma idea que usan los clientes MCP externos, como Claude Code.

Ejecuta la demo del cliente real:

python examples\real_mcp_client.py

Salida esperada:

Connected to DPR MCP server. 35 tools available.
Project: client-demo
Workspace: ws-...
Change request: CR-...
Open changes: 1

Panel de React

El panel es la interfaz orientada a los humanos.

Permite a un usuario:

• elegir la carpeta raíz local de DPR

• crear proyectos

• ver documentos

• ejecutar agentes

• inspeccionar solicitudes de cambio

• revisar diffs

• fusionar cambios aprobados

• inspeccionar conflictos

• ver el historial y la procedencia

Backend:

src/dpr_mcp/dashboard.py

Frontend:

frontend/

Agentes de LangGraph

La capa de flujo de trabajo de los agentes está aquí:

src/dpr_mcp/agents/workflows.py

Las acciones de los agentes del panel en vivo crean un DPRMCPClient real, se conectan al servidor MCP a través de stdio y llaman a las herramientas MCP. Así que la ruta del agente ahora es:

Dashboard -> LangGraph Agent -> DPRMCPClient -> MCP Server -> MCP Tools

Agentes actuales:

• Agente de borrador

• Agente de revisión

• Agente de cumplimiento

• Agente de resolución de conflictos

La integración con LLM está aquí:

src/dpr_mcp/agents/llm.py

Modos compatibles:

• Groq

• OpenAI

• Modo de respaldo si no hay ninguna clave configurada

Flujo de trabajo de los agentes

Agente de borrador

El agente de borrador crea o mejora un documento.

Ejemplo de prompt:

Write a detailed report about smart waste segregation for a college campus.

Flujo interno:

Dashboard
-> LangGraph Draft Agent
-> DPRMCPClient
-> MCP server
-> list_files
-> read_project_file if the file exists
-> create_workspace
-> create_file or edit_file
-> create_change

Resultado:

A new Change Request is created.
The file is not directly merged into main.

Agente de revisión

El agente de revisión comprueba:

• claridad

• estructura

• completitud

• utilidad técnica

• si el cambio coincide con la intención del usuario

Flujo interno:

Reviewer Agent
-> DPRMCPClient
-> get_change
-> get_diff
-> get_file_patch
-> review_change

Resultado:

A review comment is added to the Change Request.

El agente de revisión no sustituye la aprobación humana. Aporta comentarios antes de que una persona decida si fusiona el cambio.

Agente de cumplimiento

El agente de cumplimiento comprueba si un cambio es seguro y respeta las políticas.

Busca:

• tipos de archivo no admitidos

• secretos o credenciales

• texto de relleno

• evidencia inventada

• afirmaciones inseguras

• secciones de informe que faltan

Flujo interno:

Compliance Agent
-> DPRMCPClient
-> get_change
-> get_diff
-> get_file_patch
-> review_change

Resultado:

The Change Request receives a compliance review.
If there is a blocking issue, the review requests changes.

Agente de resolución de conflictos

El agente de resolución de conflictos se utiliza cuando Git detecta un conflicto de fusión real.

Flujo interno:

Resolver Agent
-> DPRMCPClient
-> get_change
-> get_conflicts
-> create_workspace
-> read_project_file
-> read_change_file
-> edit_file
-> propose_conflict_resolution

Resultado:

A new resolution Change Request is created.
The human still reviews and merges the resolution.

El agente de resolución no evita la revisión. Solo propone una corrección.

Cómo se produce un conflicto real

Un conflicto ocurre cuando dos cambios editan la misma parte del mismo archivo a partir de la misma base anterior.

Ejemplo:

main has report.md

Después:

Agent A creates CR-1 editing report.md
Agent B creates CR-2 editing the same paragraph in report.md
Human merges CR-1 first
Human tries to merge CR-2
Git detects that CR-2 was based on old main and touched the same lines
CR-2 becomes conflicted

Después:

Conflict Resolver Agent reads current main and incoming CR-2
Resolver writes a combined version in a new workspace
Resolver opens a resolution CR
Human reviews and merges the resolution CR

Este es un flujo real de conflicto de Git, no un conflicto falso que solo existe en la interfaz.

Dónde se crean los archivos

El panel solicita una carpeta raíz.

Si la raíz es:

C:\Users\janan\dpr-mcp\data

entonces el sistema usa:

data\projects      -> canonical Git repositories
data\workspaces    -> isolated Git worktrees
data\dpr_mcp.db    -> SQLite metadata database

Importante:

Documents are local files inside Git-backed project repositories.
Workspaces are temporary isolated edit areas.
SQLite stores metadata such as workspaces, changes, reviews, conflicts, and roles.

Por qué se usa Git

Git se encarga de:

• commits

• ramas

• worktrees

• diffs

• comprobaciones de viabilidad de la fusión

• conflictos de fusión

• historial de fusiones

• rollback mediante nuevos commits

Este proyecto no reinventa el control de versiones. Usa Git como fuente de verdad y añade el flujo de colaboración por encima.

Por qué se usa SQLite

Git es adecuado para el historial de archivos, pero no almacena de forma natural metadatos de colaboración como:

• estado de la solicitud de cambio

• comentarios del revisor

• aprobaciones

• registros de resolución de conflictos

• propiedad del espacio de trabajo

• asignación de roles

• registro de eventos

Esos metadatos se almacenan en SQLite.

Gobernanza humana

El sistema está diseñado intencionadamente con un humano en el bucle.

Los agentes pueden:

• redactar documentos

• revisar cambios

• comprobar el cumplimiento

• proponer resoluciones de conflictos

Las personas controlan:

• la aprobación final

• la fusión

• el rollback

• el acceso al proyecto y la selección de la raíz

Esto es importante porque el proyecto se centra en una colaboración segura asistida por IA, no en una edición autónoma sin control.

Modelo de seguridad

Las operaciones de archivos están restringidas a la raíz del repositorio y al workspace configurados.

La capa de seguridad de archivos rechaza:

• rutas absolutas

• path traversal

• symlink escapes

• null bytes

• caracteres de control

• nombres de archivo sensibles, como .env, claves privadas y credenciales

Archivos relevantes:

src/dpr_mcp/files/security.py
src/dpr_mcp/files/service.py
tests/security/

Configuración

Desde CMD en Windows:

cd /d C:\Users\janan\dpr-mcp
python -m venv .venv
.venv\Scripts\activate
pip install -e ".[dev]"
cd frontend
npm install
cd ..

Si el entorno ya existe:

cd /d C:\Users\janan\dpr-mcp
.venv\Scripts\activate

Variables de entorno

Crea un archivo .env en la raíz del proyecto si vas a usar LLMs reales.

Para Groq:

DPR_LLM_PROVIDER=groq
GROQ_API_KEY=your_key_here
DPR_LLM_MODEL=llama-3.3-70b-versatile

Para OpenAI:

DPR_LLM_PROVIDER=openai
OPENAI_API_KEY=your_key_here
DPR_LLM_MODEL=gpt-5

Si no hay ninguna clave configurada, los agentes se ejecutan en modo de respaldo, pero el contenido será básico.

Ejecutar el panel

Backend:

cd /d C:\Users\janan\dpr-mcp
.venv\Scripts\activate
python -m dotenv run -- python -m dpr_mcp.dashboard --host 127.0.0.1 --port 8787 --root data

Frontend:

cd /d C:\Users\janan\dpr-mcp\frontend
npm run dev

Abre la URL de Vite que se muestra en la terminal, normalmente:

http://127.0.0.1:5173

La API del backend del panel se ejecuta en:

http://127.0.0.1:8787

Ejecutar el servidor MCP directamente

cd /d C:\Users\janan\dpr-mcp
.venv\Scripts\activate
python -m dpr_mcp.server

Esto inicia el servidor MCP sobre stdio.

Ejecutar la demo del cliente MCP real

cd /d C:\Users\janan\dpr-mcp
.venv\Scripts\activate
python examples\real_mcp_client.py

Esto demuestra:

Python client
-> MCP stdio server
-> MCP tools
-> project/workspace/file/change created

Mapa del repositorio

src/dpr_mcp/server.py              MCP server entry point
src/dpr_mcp/dashboard.py           local dashboard HTTP API
src/dpr_mcp/mcp/tools.py           MCP tool definitions
src/dpr_mcp/mcp/client.py          real MCP stdio client
src/dpr_mcp/mcp/gateway.py         in-process MCP-shaped gateway
src/dpr_mcp/agents/workflows.py    LangGraph agent workflows
src/dpr_mcp/agents/llm.py          Groq/OpenAI/fallback generation
src/dpr_mcp/projects/              project repository management
src/dpr_mcp/workspace/             isolated worktree management
src/dpr_mcp/collaboration/         changes, reviews, approvals, conflicts
src/dpr_mcp/files/                 safe local file access
src/dpr_mcp/git/                   Git CLI wrapper
src/dpr_mcp/persistence/           SQLite models and repositories
src/dpr_mcp/provenance/            provenance reconstruction
frontend/                          React dashboard
examples/                          runnable MCP and conflict demos
tests/                             unit, integration, security, MCP tests
docs/                              architecture and technical docs

Estado actual

Se ha implementado:

• servidor MCP

• cliente MCP real sobre stdio

• panel de React

• agentes de LangGraph

• integración con LLM

• repositorios de proyectos Git locales

• espacios de trabajo aislados

• solicitudes de cambio

• revisiones

• comprobaciones de cumplimiento

• flujo de fusión

• detección de conflictos

• propuestas de resolución de conflictos

• rollback

• procedencia

• diagramas de arquitectura

• pruebas