Procesador de documentos MCP

Un sistema de procesamiento de documentos inteligente que utiliza el Protocolo de Contexto de Modelo (MCP) para extraer, analizar y enrutar documentos comerciales automáticamente.

Descripción general del proyecto

Este proyecto demuestra cómo usar MCP para resolver un desafío empresarial real: automatizar los flujos de trabajo de procesamiento de documentos. El sistema puede:

Clasificar los documentos entrantes (facturas, contratos, correos electrónicos)
Extraer información relevante utilizando modelos ML
Procesar documentos según su tipo Mantener el contexto durante todo el proceso de procesamiento Exponer la funcionalidad a través de una API REST

Componentes clave del MCP

Objetos de contexto : centrales para MCP, estos objetos (implementados en MCPContext ) transportan información entre los pasos de procesamiento y mantienen el estado del documento.
Sistema de memoria : almacena objetos de contexto entre los pasos de procesamiento, con backends conectables.
Protocolos : Define interfaces claras para procesadores y modelos, garantizando la modularidad.
Enrutador : enruta de forma inteligente los documentos a procesadores especializados según el contenido.

Valor empresarial

Esta solución aborda varios desafíos comerciales:

Procesamiento manual reducido: automatiza la extracción de datos de los documentos
Coherencia: garantiza un procesamiento consistente en todos los tipos de documentos
Auditabilidad: Mantiene el historial de procesamiento y los puntajes de confianza
Escalabilidad: El diseño modular permite agregar nuevos tipos de documentos fácilmente

Aspectos técnicos destacados

Utiliza modelos basados en BERT para la clasificación y extracción de entidades.
Modelo T5 para el resumen de documentos
FastAPI para interfaz REST
Arquitectura conectable para una fácil ampliación
Registro completo y gestión de errores
Interfaz de usuario basada en React para una mejor experiencia de usuario

Descripción general

El Procesador de Documentos MCP está diseñado para resolver el desafío empresarial habitual de procesar diversos tipos de documentos (facturas, contratos, correos electrónicos, etc.) de forma consistente y automatizada. Utiliza el marco del Protocolo de Contexto de Modelo para gestionar el flujo de información entre los diferentes componentes del sistema.

Características principales

Clasificación de documentos : identifica automáticamente los tipos de documentos
Extracción de información : extrae información clave de los documentos
Enrutamiento de documentos : enruta los documentos a los procesadores adecuados
Gestión del contexto : mantiene el contexto durante todo el proceso de procesamiento.
Interfaz API : proporciona una API RESTful para la integración con otros sistemas

Arquitectura

El sistema está construido alrededor del Protocolo de Contexto Modelo (MCP), que proporciona:

Objetos de contexto : transportan información a través de los pasos de procesamiento
# Example of MCPContext usage context = MCPContext( document_id=document_id, raw_text=text, metadata=metadata ) # Adding extracted data with confidence scores context.add_extracted_data("invoice_number", "INV-12345", confidence=0.95) # Tracking processing history context.add_to_history( processor_name="InvoiceProcessor", status="completed", details={"processing_time": "0.5s"} )
Sistema de memoria : almacena objetos de contexto entre llamadas API
# Storing context in memory memory.store(document_id, context) # Retrieving context from memory context = memory.retrieve(document_id)
Protocolos : Define interfaces para procesadores y modelos
# Processor protocol example class Processor(Protocol): @abstractmethod def process(self, context: MCPContext) -> MCPContext: """Process the document and update the context.""" pass @abstractmethod def can_handle(self, context: MCPContext) -> bool: """Determine if this processor can handle the given document.""" pass
Enrutador : Enruta documentos a procesadores especializados apropiados
# Router usage example processor = processor_router.route(context) if processor: processed_context = processor.process(context)

Diagrama de flujo MCP

Document Upload → MCPContext Creation → Memory Storage → 
Document Processing → Router Selection → Specialized Processor → 
Entity Extraction → Context Update → Memory Storage → API Response

Detalles de implementación de MCP

La implementación del Protocolo de Contexto Modelo en este proyecto ofrece varias ventajas clave:

1. Procesamiento con estado y persistencia del contexto

La clase MCPContext mantiene el estado durante todo el ciclo de vida del procesamiento del documento:

# Context is created during document upload
@router.post("/documents/upload")
async def upload_document(file: UploadFile, memory: MemoryInterface):
    # Create a context
    context = MCPContext(
        document_id=document_id,
        raw_text=text,
        metadata=metadata
    )
    
    # Store in memory for later retrieval
    memory.store(document_id, context)

2. Sistema de memoria enchufable

El sistema de memoria está diseñado para ser conectable, lo que permite diferentes backends de almacenamiento:

# Factory function in memory.py
def get_memory_store(memory_type: str = "in_memory", **kwargs) -> MemoryInterface:
    if memory_type == "in_memory":
        return InMemoryStorage(default_ttl=kwargs.get("ttl", 3600))
    # Additional implementations can be added here

3. Seguimiento de la confianza

MCP realiza un seguimiento de los puntajes de confianza de todos los datos extraídos, lo que permite una mejor toma de decisiones:

# In entity_extractor.py
entity_data = {
    "text": text[current_entity["start"]:current_entity["end"]],
    "start": current_entity["start"],
    "end": current_entity["end"],
    "confidence": avg_confidence
}

4. Historial de procesamiento

Cada paso del procesamiento se registra en el historial del contexto, lo que proporciona auditabilidad:

# In router.py
context.add_to_history(
    processor_name=processor.__class__.__name__,
    status="completed"
)

5. Enrutamiento inteligente de documentos

El ProcessorRouter determina el procesador apropiado para cada documento:

# In router.py
def route(self, context: MCPContext) -> Optional[Processor]:
    for processor in self.processors:
        if processor.can_handle(context):
            return processor
    return None

6. Extensibilidad

Agregar nuevos tipos de documentos es sencillo implementando el protocolo Processor :

# Example of adding a new processor
class NewDocumentProcessor(BaseProcessor):
    def can_handle(self, context: MCPContext) -> bool:
        # Logic to determine if this processor can handle the document
        pass
        
    def process(self, context: MCPContext) -> MCPContext:
        # Document processing logic
        pass

Procesadores de documentos

El sistema incluye procesadores especializados para diferentes tipos de documentos:

Procesador de facturas : extrae proveedores, clientes, artículos de línea, totales, etc.
Procesador de contratos : extrae partes, fechas clave, términos, etc.
Procesador de correo electrónico : extrae remitente, destinatarios, asunto, cuerpo, etc.

Modelos de aprendizaje automático

Se utilizan varios modelos de ML para diferentes tareas:

Clasificador de documentos : modelo basado en BERT para la clasificación de tipos de documentos
Extractor de entidades : modelo de reconocimiento de entidades con nombre para extraer información clave
Summarizer : modelo basado en T5 para generar resúmenes de documentos

Interfaz de usuario

El procesador de documentos MCP incluye una moderna interfaz de usuario basada en React que proporciona una forma intuitiva de interactuar con el sistema de procesamiento de documentos. La interfaz de usuario está desarrollada con Material-UI y ofrece las siguientes características:

Características de la interfaz de usuario

Panel de control : descripción general de los documentos procesados con estadísticas y acceso rápido a los detalles del documento
Carga de documentos : Interfaz de arrastrar y soltar para cargar nuevos documentos
Procesamiento de documentos : Flujo de trabajo paso a paso para el procesamiento de documentos
Visor de documentos : vista detallada de los documentos procesados con información extraída
Historial de procesamiento : vista de la línea de tiempo de todos los pasos del procesamiento para auditabilidad

Arquitectura de interfaz de usuario

El frontend está construido con:

React : para construir los componentes de la interfaz de usuario
Material-UI : Para un diseño consistente y responsivo
React Router : para navegar entre diferentes vistas
Axios : Para la comunicación API con el backend
Chart.js : Para la visualización de datos de estadísticas de documentos

Integración UI-Backend

El frontend se comunica con el backend a través de una API RESTful, con los siguientes puntos finales principales:

GET /api/documents : Recuperar todos los documentos
POST /api/documents/upload : Subir un nuevo documento
POST /api/documents/{document_id}/process : Procesar un documento
GET /api/documents/{document_id} : Obtener detalles del documento
DELETE /api/documents/{document_id} : Eliminar un documento

Arquitectura completa del sistema

El procesador de documentos MCP sigue una arquitectura en capas que integra la interfaz, la capa API, los componentes de procesamiento y los modelos de aprendizaje automático:

┌─────────────────────────────────────────────────────────────────────────┐
│                             Frontend Layer                              │
│                                                                         │
│  ┌─────────────┐      ┌─────────────┐      ┌─────────────────────────┐  │
│  │  Dashboard  │      │   Upload    │      │    Document Viewer      │  │
│  └─────────────┘      └─────────────┘      └─────────────────────────┘  │
│          │                   │                         │                │
└──────────┼───────────────────┼─────────────────────────┼────────────────┘
           │                   │                         │
           │                   │                         │
           ▼                   ▼                         ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                              API Layer                                  │
│                                                                         │
│  ┌─────────────┐      ┌─────────────┐      ┌─────────────────────────┐  │
│  │ Document    │      │ Document    │      │    Document             │  │
│  │ Upload API  │      │ Process API │      │    Retrieval API        │  │
│  └─────────────┘      └─────────────┘      └─────────────────────────┘  │
│          │                   │                         │                │
└──────────┼───────────────────┼─────────────────────────┼────────────────┘
           │                   │                         │
           │                   │                         │
           ▼                   ▼                         ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                         MCP Core Components                             │
│                                                                         │
│  ┌─────────────┐      ┌─────────────┐      ┌─────────────────────────┐  │
│  │ MCPContext  │◄────►│ Memory      │◄────►│    Processor Router     │  │
│  └─────────────┘      └─────────────┘      └─────────────────────────┘  │
│          │                                            │                 │
└──────────┼────────────────────────────────────────────┼─────────────────┘
           │                                            │
           │                                            │
           ▼                                            ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                         Document Processors                             │
│                                                                         │
│  ┌─────────────┐      ┌─────────────┐      ┌─────────────────────────┐  │
│  │ Invoice     │      │ Contract    │      │    Email                │  │
│  │ Processor   │      │ Processor   │      │    Processor            │  │
│  └─────────────┘      └─────────────┘      └─────────────────────────┘  │
│          │                   │                         │                │
└──────────┼───────────────────┼─────────────────────────┼────────────────┘
           │                   │                         │
           │                   │                         │
           ▼                   ▼                         ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                         ML Models Layer                                 │
│                                                                         │
│  ┌─────────────┐      ┌─────────────┐      ┌─────────────────────────┐  │
│  │ Document    │      │ Entity      │      │    Summarizer           │  │
│  │ Classifier  │      │ Extractor   │      │                         │  │
│  └─────────────┘      └─────────────┘      └─────────────────────────┘  │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Flujo de trabajo completo

El flujo de trabajo de procesamiento de documentos implica múltiples pasos en los componentes del sistema:

Carga de documentos :
- El usuario carga un documento a través de la interfaz de usuario
- El frontend envía el documento a la API del backend
- El backend crea un objeto MCPContext con metadatos del documento
- El contexto se almacena en el sistema de memoria
Clasificación de documentos :
- El usuario inicia el procesamiento a través de la interfaz de usuario
- El backend recupera el contexto del documento de la memoria
- El modelo clasificador de documentos determina el tipo de documento
- El contexto se actualiza con la información del tipo de documento
Procesamiento de documentos :
- El enrutador del procesador selecciona el procesador apropiado según el tipo de documento
- El procesador seleccionado (factura, contrato o correo electrónico) procesa el documento
- El procesador utiliza Entity Extractor para identificar información clave
- Los datos extraídos se agregan al contexto con puntajes de confianza.
Recuperación de resultados :
- El contexto actualizado se almacena nuevamente en la memoria
- La interfaz de usuario recupera y muestra la información del documento procesado
- El usuario puede ver los datos extraídos, los puntajes de confianza y el historial de procesamiento.
Auditoría y revisión :
- Todos los pasos del procesamiento se registran en el historial de procesamiento del contexto.
- La interfaz de usuario proporciona visualización de puntuaciones de confianza para los datos extraídos
- El usuario puede revisar el texto del documento junto con la información extraída

Empezando

Prerrequisitos

Python 3.8+
Node.js 14+ y npm (para el frontend)
Dependencias enumeradas en requirements.txt

Instalación y configuración

Configuración del backend

Clonar el repositorio
git clone https://github.com/yourusername/mcp_document_processor.git cd mcp_document_processor
Crear y activar un entorno virtual
python -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate
Instalar dependencias de backend
pip install -r requirements.txt
Crear un directorio de datos para el almacenamiento de documentos (si no existe)
mkdir -p data

Configuración de la interfaz

Navegue hasta el directorio del frontend
cd frontend
Instalar dependencias del frontend
npm install

Ejecutar la aplicación

Iniciar el servidor backend

Desde el directorio raíz del proyecto (con entorno virtual activado):
python app.py
Esto iniciará el servidor FastAPI en http://localhost:8000 .
Puede acceder a la documentación de la API en http://localhost:8000/docs

Iniciar el servidor de desarrollo frontend

Abrir una nueva ventana/pestaña de terminal
Navegue hasta el directorio del frontend:
cd /path/to/mcp_document_processor/frontend
Inicie el servidor de desarrollo de React:
npm start
Esto iniciará la interfaz en http://localhost:3000 .

Uso de la aplicación

Abra su navegador y navegue a http://localhost:3000
Utilice la navegación de la barra lateral para:
- Ver el panel de control
- Subir nuevos documentos
- Procesar y ver detalles del documento

Ejemplo de flujo de trabajo

Subir un documento :
- Haga clic en "Subir documento" en la barra lateral.
- Arrastre y suelte un documento (PDF, imagen o archivo de texto)
- Haga clic en el botón "Cargar documento"
Procesar el documento :
- Después de cargar correctamente el documento, haga clic en "Procesar documento".
- Espere a que se complete el procesamiento
Ver resultados :
- Ver datos extraídos, puntajes de confianza y el historial de procesamiento
- Navegue al Panel de Control para ver todos los documentos procesados

Uso de la API

También puedes interactuar directamente con la API:

GET /api/documents : Recuperar todos los documentos
POST /api/documents/upload : Subir un nuevo documento
POST /api/documents/{document_id}/process : Procesar un documento
GET /api/documents/{document_id} : Obtener detalles del documento
DELETE /api/documents/{document_id} : Eliminar un documento

Ampliación del sistema

Agregar un nuevo procesador de documentos

Cree una nueva clase de procesador que herede de BaseProcessor
Implementar los métodos can_handle y process
Agregue el procesador al enrutador en api/routes.py

Agregar un nuevo modelo

Cree una nueva clase de modelo que implemente el protocolo apropiado
Agregar configuración en config/config.yaml
Integrar el modelo con el procesador relevante

Licencia

Licencia MIT

Integrations