[{"_1":2,"_318":-5,"_319":-5},"loaderData",{"_3":4,"_22":23,"_24":25,"_257":258},"root",{"_5":6,"_7":8},"toasts",[],"visitor",{"_9":10,"_11":12},"viewportWidth",1280,"visitorSession",{"_13":14,"_16":17,"_18":-5,"_19":20,"_21":-5},"attributes",[15],"BOT","id",5890406,"membership","referenceId","01969a91-d82d-7e57-a666-c55fba0f827d","userAccount","routes/_public/_layout",{},"routes/_public/mcp/servers/~namespace/~slug/_pages/_layout",{"_26":27,"_68":-5,"_69":28,"_29":70,"_174":175,"_256":116},"availableLocales",[28,40,47,54,61],{"_29":30,"_33":37,"_38":39},"mcpServer",{"_31":32,"_33":34,"_35":36},"description","An intelligent document processing system that automatically classifies, extracts information from, and routes business documents using the Model Context Protocol (MCP).","name","MCP Document Processor","readme","# MCP Document Processor\n\nAn intelligent document processing system that uses the Model Context Protocol (MCP) to extract, analyze, and route business documents automatically.\n\n\n## Project Overview\nThis project demonstrates how to use MCP to solve a real business challenge: automating document processing workflows. The system can:\n\n- Classify incoming documents (invoices, contracts, emails)\n- Extract relevant information using ML models\n- Process documents according to their type\nMaintain context throughout the processing pipeline\nExpose functionality through a REST API\n\n## Key MCP Components\n\n- **Context Objects**: Central to MCP, these objects (implemented in `MCPContext`) carry information between processing steps and maintain the document's state.\n- **Memory System**: Stores context objects between processing steps, with pluggable backends.\n- **Protocols**: Defines clear interfaces for processors and models, ensuring modularity.\n- **Router**: Intelligently routes documents to specialized processors based on content.\n\n## Business Value\nThis solution addresses several business challenges:\n\n- Reduced Manual Processing: Automates extraction of data from documents\n- Consistency: Ensures consistent processing across document types\n- Auditability: Maintains processing history and confidence scores\n- Scalability: Modular design allows adding new document types easily\n\n## Technical Highlights\n\n- Uses BERT-based models for classification and entity extraction\n- T5 model for document summarization\n- FastAPI for REST interface\n- Pluggable architecture for easy extension\n- Comprehensive logging and error handling\n- React based UI for better user experience\n\n## Overview\n\nThe MCP Document Processor is designed to solve the common business challenge of processing various types of documents (invoices, contracts, emails, etc.) in a consistent and automated way. It utilizes the Model Context Protocol framework to manage information flow between different components of the system.\n\n## Key Features\n\n- **Document Classification**: Automatically identifies document types\n- **Information Extraction**: Extracts key information from documents\n- **Document Routing**: Routes documents to the appropriate processors\n- **Context Management**: Maintains context throughout the processing pipeline\n- **API Interface**: Provides a RESTful API for integration with other systems\n\n## Architecture\n\nThe system is built around the Model Context Protocol (MCP), which provides:\n\n1. **Context Objects**: Carry information across processing steps\n ```python\n # Example of MCPContext usage\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n \n # Adding extracted data with confidence scores\n context.add_extracted_data(\"invoice_number\", \"INV-12345\", confidence=0.95)\n \n # Tracking processing history\n context.add_to_history(\n processor_name=\"InvoiceProcessor\",\n status=\"completed\",\n details={\"processing_time\": \"0.5s\"}\n )\n ```\n\n2. **Memory System**: Stores context objects between API calls\n ```python\n # Storing context in memory\n memory.store(document_id, context)\n \n # Retrieving context from memory\n context = memory.retrieve(document_id)\n ```\n\n3. **Protocols**: Define interfaces for processors and models\n ```python\n # Processor protocol example\n class Processor(Protocol):\n @abstractmethod\n def process(self, context: MCPContext) -> MCPContext:\n \"\"\"Process the document and update the context.\"\"\"\n pass\n \n @abstractmethod\n def can_handle(self, context: MCPContext) -> bool:\n \"\"\"Determine if this processor can handle the given document.\"\"\"\n pass\n ```\n\n4. **Router**: Routes documents to appropriate specialized processors\n ```python\n # Router usage example\n processor = processor_router.route(context)\n if processor:\n processed_context = processor.process(context)\n ```\n\n### MCP Flow Diagram\n\n```\nDocument Upload → MCPContext Creation → Memory Storage → \nDocument Processing → Router Selection → Specialized Processor → \nEntity Extraction → Context Update → Memory Storage → API Response\n```\n\n## MCP Implementation Details\n\nThe Model Context Protocol implementation in this project offers several key advantages:\n\n### 1. Stateful Processing with Context Persistence\n\nThe `MCPContext` class maintains state throughout the document processing lifecycle:\n\n```python\n# Context is created during document upload\n@router.post(\"/documents/upload\")\nasync def upload_document(file: UploadFile, memory: MemoryInterface):\n # Create a context\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n \n # Store in memory for later retrieval\n memory.store(document_id, context)\n```\n\n### 2. Pluggable Memory System\n\nThe memory system is designed to be pluggable, allowing different storage backends:\n\n```python\n# Factory function in memory.py\ndef get_memory_store(memory_type: str = \"in_memory\", **kwargs) -> MemoryInterface:\n if memory_type == \"in_memory\":\n return InMemoryStorage(default_ttl=kwargs.get(\"ttl\", 3600))\n # Additional implementations can be added here\n```\n\n### 3. Confidence Tracking\n\nMCP tracks confidence scores for all extracted data, enabling better decision-making:\n\n```python\n# In entity_extractor.py\nentity_data = {\n \"text\": text[current_entity[\"start\"]:current_entity[\"end\"]],\n \"start\": current_entity[\"start\"],\n \"end\": current_entity[\"end\"],\n \"confidence\": avg_confidence\n}\n```\n\n### 4. Processing History\n\nEach processing step is recorded in the context's history, providing auditability:\n\n```python\n# In router.py\ncontext.add_to_history(\n processor_name=processor.__class__.__name__,\n status=\"completed\"\n)\n```\n\n### 5. Intelligent Document Routing\n\nThe `ProcessorRouter` determines the appropriate processor for each document:\n\n```python\n# In router.py\ndef route(self, context: MCPContext) -> Optional[Processor]:\n for processor in self.processors:\n if processor.can_handle(context):\n return processor\n return None\n```\n\n### 6. Extensibility\n\nAdding new document types is straightforward by implementing the `Processor` protocol:\n\n```python\n# Example of adding a new processor\nclass NewDocumentProcessor(BaseProcessor):\n def can_handle(self, context: MCPContext) -> bool:\n # Logic to determine if this processor can handle the document\n pass\n \n def process(self, context: MCPContext) -> MCPContext:\n # Document processing logic\n pass\n```\n\n## Document Processors\n\nThe system includes specialized processors for different document types:\n\n- **Invoice Processor**: Extracts vendor, customer, line items, totals, etc.\n- **Contract Processor**: Extracts parties, key dates, terms, etc.\n- **Email Processor**: Extracts sender, recipients, subject, body, etc.\n\n## Machine Learning Models\n\nSeveral ML models are used for different tasks:\n\n- **Document Classifier**: BERT-based model for document type classification\n- **Entity Extractor**: Named Entity Recognition model for extracting key information\n- **Summarizer**: T5-based model for generating document summaries\n\n## User Interface\n\nThe MCP Document Processor includes a modern React-based user interface that provides an intuitive way to interact with the document processing system. The UI is built with Material-UI and offers the following features:\n\n### UI Features\n\n- **Dashboard**: Overview of processed documents with statistics and quick access to document details\n- **Document Upload**: Drag-and-drop interface for uploading new documents\n- **Document Processing**: Step-by-step workflow for processing documents\n- **Document Viewer**: Detailed view of processed documents with extracted information\n- **Processing History**: Timeline view of all processing steps for auditability\n\n### UI Architecture\n\nThe frontend is built with:\n\n- **React**: For building the user interface components\n- **Material-UI**: For consistent, responsive design\n- **React Router**: For navigation between different views\n- **Axios**: For API communication with the backend\n- **Chart.js**: For data visualization of document statistics\n\n### UI-Backend Integration\n\nThe frontend communicates with the backend through a RESTful API, with the following main endpoints:\n\n- `GET /api/documents`: Retrieve all documents\n- `POST /api/documents/upload`: Upload a new document\n- `POST /api/documents/{document_id}/process`: Process a document\n- `GET /api/documents/{document_id}`: Get document details\n- `DELETE /api/documents/{document_id}`: Delete a document\n\n## Complete System Architecture\n\nThe MCP Document Processor follows a layered architecture that integrates the frontend, API layer, processing components, and machine learning models:\n\n```\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Frontend Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Dashboard │ │ Upload │ │ Document Viewer │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ API Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Document │ │ Document │ │\n│ │ Upload API │ │ Process API │ │ Retrieval API │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ MCP Core Components │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ MCPContext │◄────►│ Memory │◄────►│ Processor Router │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │\n└──────────┼────────────────────────────────────────────┼─────────────────┘\n │ │\n │ │\n ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Document Processors │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Invoice │ │ Contract │ │ Email │ │\n│ │ Processor │ │ Processor │ │ Processor │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ ML Models Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Entity │ │ Summarizer │ │\n│ │ Classifier │ │ Extractor │ │ │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────────┘\n```\n\n## Complete Workflow\n\nThe document processing workflow involves multiple steps across the system components:\n\n1. **Document Upload**:\n - User uploads a document through the UI\n - Frontend sends the document to the backend API\n - Backend creates an MCPContext object with document metadata\n - Context is stored in the Memory system\n\n2. **Document Classification**:\n - User initiates processing through the UI\n - Backend retrieves the document context from Memory\n - Document Classifier model determines document type\n - Context is updated with document type information\n\n3. **Document Processing**:\n - Processor Router selects the appropriate processor based on document type\n - Selected processor (Invoice, Contract, or Email) processes the document\n - Processor uses Entity Extractor to identify key information\n - Extracted data is added to the context with confidence scores\n\n4. **Result Retrieval**:\n - Updated context is stored back in Memory\n - UI retrieves and displays the processed document information\n - User can view extracted data, confidence scores, and processing history\n\n5. **Audit and Review**:\n - All processing steps are recorded in the context's processing history\n - UI provides visualization of confidence scores for extracted data\n - User can review the document text alongside extracted information\n\n## Getting Started\n\n### Prerequisites\n\n- Python 3.8+\n- Node.js 14+ and npm (for the frontend)\n- Dependencies listed in requirements.txt\n\n### Installation and Setup\n\n#### Backend Setup\n\n1. Clone the repository\n ```bash\n git clone https://github.com/yourusername/mcp_document_processor.git\n cd mcp_document_processor\n ```\n\n2. Create and activate a virtual environment\n ```bash\n python -m venv venv\n source venv/bin/activate # On Windows: venv\\Scripts\\activate\n ```\n\n3. Install backend dependencies\n ```bash\n pip install -r requirements.txt\n ```\n\n4. Create a data directory for document storage (if it doesn't exist)\n ```bash\n mkdir -p data\n ```\n\n#### Frontend Setup\n\n1. Navigate to the frontend directory\n ```bash\n cd frontend\n ```\n\n2. Install frontend dependencies\n ```bash\n npm install\n ```\n\n### Running the Application\n\n#### Start the Backend Server\n\n1. From the root directory of the project (with virtual environment activated):\n ```bash\n python app.py\n ```\n This will start the FastAPI server on http://localhost:8000.\n\n2. You can access the API documentation at http://localhost:8000/docs\n\n#### Start the Frontend Development Server\n\n1. Open a new terminal window/tab\n2. Navigate to the frontend directory:\n ```bash\n cd /path/to/mcp_document_processor/frontend\n ```\n\n3. Start the React development server:\n ```bash\n npm start\n ```\n This will start the frontend on http://localhost:3000.\n\n### Using the Application\n\n1. Open your browser and navigate to http://localhost:3000\n2. Use the sidebar navigation to:\n - View the dashboard\n - Upload new documents\n - Process and view document details\n\n#### Example Workflow\n\n1. **Upload a Document**:\n - Click on \"Upload Document\" in the sidebar\n - Drag and drop a document (PDF, image, or text file)\n - Click \"Upload Document\" button\n\n2. **Process the Document**:\n - After successful upload, click \"Process Document\"\n - Wait for processing to complete\n\n3. **View Results**:\n - View extracted data, confidence scores, and processing history\n - Navigate to the Dashboard to see all processed documents\n\n### API Usage\n\nYou can also interact directly with the API:\n\n- `GET /api/documents`: Retrieve all documents\n- `POST /api/documents/upload`: Upload a new document\n- `POST /api/documents/{document_id}/process`: Process a document\n- `GET /api/documents/{document_id}`: Get document details\n- `DELETE /api/documents/{document_id}`: Delete a document\n\n## Extending the System\n\n### Adding a New Document Processor\n\n1. Create a new processor class that inherits from `BaseProcessor`\n2. Implement the `can_handle` and `process` methods\n3. Add the processor to the router in `api/routes.py`\n\n### Adding a New Model\n\n1. Create a new model class that implements the appropriate protocol\n2. Add configuration in `config/config.yaml`\n3. Integrate the model with the relevant processor\n\n## License\n\n[MIT License](LICENSE)\n","English","tag","en-US",{"_29":41,"_33":45,"_38":46},{"_31":42,"_33":43,"_35":44},"Un sistema de procesamiento de documentos inteligente que clasifica, extrae información y enruta automáticamente documentos comerciales utilizando el Protocolo de Contexto de Modelo (MCP).","Procesador de documentos MCP","# Procesador de documentos MCP\n\nUn sistema de procesamiento de documentos inteligente que utiliza el Protocolo de Contexto de Modelo (MCP) para extraer, analizar y enrutar documentos comerciales automáticamente.\n\n## Descripción general del proyecto\n\nEste 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:\n\n* Clasificar los documentos entrantes (facturas, contratos, correos electrónicos)\n* Extraer información relevante utilizando modelos ML\n* 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\n\n## Componentes clave del MCP\n\n* **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.\n* **Sistema de memoria** : almacena objetos de contexto entre los pasos de procesamiento, con backends conectables.\n* **Protocolos** : Define interfaces claras para procesadores y modelos, garantizando la modularidad.\n* **Enrutador** : enruta de forma inteligente los documentos a procesadores especializados según el contenido.\n\n## Valor empresarial\n\nEsta solución aborda varios desafíos comerciales:\n\n* Procesamiento manual reducido: automatiza la extracción de datos de los documentos\n* Coherencia: garantiza un procesamiento consistente en todos los tipos de documentos\n* Auditabilidad: Mantiene el historial de procesamiento y los puntajes de confianza\n* Escalabilidad: El diseño modular permite agregar nuevos tipos de documentos fácilmente\n\n## Aspectos técnicos destacados\n\n* Utiliza modelos basados en BERT para la clasificación y extracción de entidades.\n* Modelo T5 para el resumen de documentos\n* FastAPI para interfaz REST\n* Arquitectura conectable para una fácil ampliación\n* Registro completo y gestión de errores\n* Interfaz de usuario basada en React para una mejor experiencia de usuario\n\n## Descripción general\n\nEl 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.\n\n## Características principales\n\n* **Clasificación de documentos** : identifica automáticamente los tipos de documentos\n* **Extracción de información** : extrae información clave de los documentos\n* **Enrutamiento de documentos** : enruta los documentos a los procesadores adecuados\n* **Gestión del contexto** : mantiene el contexto durante todo el proceso de procesamiento.\n* **Interfaz API** : proporciona una API RESTful para la integración con otros sistemas\n\n## Arquitectura\n\nEl sistema está construido alrededor del Protocolo de Contexto Modelo (MCP), que proporciona:\n\n1. **Objetos de contexto** : transportan información a través de los pasos de procesamiento\n\n ```python\n # Example of MCPContext usage\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n\n # Adding extracted data with confidence scores\n context.add_extracted_data(\"invoice_number\", \"INV-12345\", confidence=0.95)\n\n # Tracking processing history\n context.add_to_history(\n processor_name=\"InvoiceProcessor\",\n status=\"completed\",\n details={\"processing_time\": \"0.5s\"}\n )\n ```\n\n2. **Sistema de memoria** : almacena objetos de contexto entre llamadas API\n\n ```python\n # Storing context in memory\n memory.store(document_id, context)\n\n # Retrieving context from memory\n context = memory.retrieve(document_id)\n ```\n\n3. **Protocolos** : Define interfaces para procesadores y modelos\n\n ```python\n # Processor protocol example\n class Processor(Protocol):\n @abstractmethod\n def process(self, context: MCPContext) -> MCPContext:\n \"\"\"Process the document and update the context.\"\"\"\n pass\n \n @abstractmethod\n def can_handle(self, context: MCPContext) -> bool:\n \"\"\"Determine if this processor can handle the given document.\"\"\"\n pass\n ```\n\n4. **Enrutador** : Enruta documentos a procesadores especializados apropiados\n\n ```python\n # Router usage example\n processor = processor_router.route(context)\n if processor:\n processed_context = processor.process(context)\n ```\n\n### Diagrama de flujo MCP\n\n```\nDocument Upload → MCPContext Creation → Memory Storage → \nDocument Processing → Router Selection → Specialized Processor → \nEntity Extraction → Context Update → Memory Storage → API Response\n```\n\n## Detalles de implementación de MCP\n\nLa implementación del Protocolo de Contexto Modelo en este proyecto ofrece varias ventajas clave:\n\n### 1. Procesamiento con estado y persistencia del contexto\n\nLa clase `MCPContext` mantiene el estado durante todo el ciclo de vida del procesamiento del documento:\n\n```python\n# Context is created during document upload\n@router.post(\"/documents/upload\")\nasync def upload_document(file: UploadFile, memory: MemoryInterface):\n # Create a context\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n \n # Store in memory for later retrieval\n memory.store(document_id, context)\n```\n\n### 2. Sistema de memoria enchufable\n\nEl sistema de memoria está diseñado para ser conectable, lo que permite diferentes backends de almacenamiento:\n\n```python\n# Factory function in memory.py\ndef get_memory_store(memory_type: str = \"in_memory\", **kwargs) -> MemoryInterface:\n if memory_type == \"in_memory\":\n return InMemoryStorage(default_ttl=kwargs.get(\"ttl\", 3600))\n # Additional implementations can be added here\n```\n\n### 3. Seguimiento de la confianza\n\nMCP realiza un seguimiento de los puntajes de confianza de todos los datos extraídos, lo que permite una mejor toma de decisiones:\n\n```python\n# In entity_extractor.py\nentity_data = {\n \"text\": text[current_entity[\"start\"]:current_entity[\"end\"]],\n \"start\": current_entity[\"start\"],\n \"end\": current_entity[\"end\"],\n \"confidence\": avg_confidence\n}\n```\n\n### 4. Historial de procesamiento\n\nCada paso del procesamiento se registra en el historial del contexto, lo que proporciona auditabilidad:\n\n```python\n# In router.py\ncontext.add_to_history(\n processor_name=processor.__class__.__name__,\n status=\"completed\"\n)\n```\n\n### 5. Enrutamiento inteligente de documentos\n\nEl `ProcessorRouter` determina el procesador apropiado para cada documento:\n\n```python\n# In router.py\ndef route(self, context: MCPContext) -> Optional[Processor]:\n for processor in self.processors:\n if processor.can_handle(context):\n return processor\n return None\n```\n\n### 6. Extensibilidad\n\nAgregar nuevos tipos de documentos es sencillo implementando el protocolo `Processor` :\n\n```python\n# Example of adding a new processor\nclass NewDocumentProcessor(BaseProcessor):\n def can_handle(self, context: MCPContext) -> bool:\n # Logic to determine if this processor can handle the document\n pass\n \n def process(self, context: MCPContext) -> MCPContext:\n # Document processing logic\n pass\n```\n\n## Procesadores de documentos\n\nEl sistema incluye procesadores especializados para diferentes tipos de documentos:\n\n* **Procesador de facturas** : extrae proveedores, clientes, artículos de línea, totales, etc.\n* **Procesador de contratos** : extrae partes, fechas clave, términos, etc.\n* **Procesador de correo electrónico** : extrae remitente, destinatarios, asunto, cuerpo, etc.\n\n## Modelos de aprendizaje automático\n\nSe utilizan varios modelos de ML para diferentes tareas:\n\n* **Clasificador de documentos** : modelo basado en BERT para la clasificación de tipos de documentos\n* **Extractor de entidades** : modelo de reconocimiento de entidades con nombre para extraer información clave\n* **Summarizer** : modelo basado en T5 para generar resúmenes de documentos\n\n## Interfaz de usuario\n\nEl 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:\n\n### Características de la interfaz de usuario\n\n* **Panel de control** : descripción general de los documentos procesados con estadísticas y acceso rápido a los detalles del documento\n* **Carga de documentos** : Interfaz de arrastrar y soltar para cargar nuevos documentos\n* **Procesamiento de documentos** : Flujo de trabajo paso a paso para el procesamiento de documentos\n* **Visor de documentos** : vista detallada de los documentos procesados con información extraída\n* **Historial de procesamiento** : vista de la línea de tiempo de todos los pasos del procesamiento para auditabilidad\n\n### Arquitectura de interfaz de usuario\n\nEl frontend está construido con:\n\n* **React** : para construir los componentes de la interfaz de usuario\n* **Material-UI** : Para un diseño consistente y responsivo\n* **React Router** : para navegar entre diferentes vistas\n* **Axios** : Para la comunicación API con el backend\n* **Chart.js** : Para la visualización de datos de estadísticas de documentos\n\n### Integración UI-Backend\n\nEl frontend se comunica con el backend a través de una API RESTful, con los siguientes puntos finales principales:\n\n* `GET /api/documents` : Recuperar todos los documentos\n* `POST /api/documents/upload` : Subir un nuevo documento\n* `POST /api/documents/{document_id}/process` : Procesar un documento\n* `GET /api/documents/{document_id}` : Obtener detalles del documento\n* `DELETE /api/documents/{document_id}` : Eliminar un documento\n\n## Arquitectura completa del sistema\n\nEl 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:\n\n```\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Frontend Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Dashboard │ │ Upload │ │ Document Viewer │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ API Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Document │ │ Document │ │\n│ │ Upload API │ │ Process API │ │ Retrieval API │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ MCP Core Components │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ MCPContext │◄────►│ Memory │◄────►│ Processor Router │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │\n└──────────┼────────────────────────────────────────────┼─────────────────┘\n │ │\n │ │\n ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Document Processors │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Invoice │ │ Contract │ │ Email │ │\n│ │ Processor │ │ Processor │ │ Processor │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ ML Models Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Entity │ │ Summarizer │ │\n│ │ Classifier │ │ Extractor │ │ │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────────┘\n```\n\n## Flujo de trabajo completo\n\nEl flujo de trabajo de procesamiento de documentos implica múltiples pasos en los componentes del sistema:\n\n1. **Carga de documentos** :\n\n * El usuario carga un documento a través de la interfaz de usuario\n * El frontend envía el documento a la API del backend\n * El backend crea un objeto MCPContext con metadatos del documento\n * El contexto se almacena en el sistema de memoria\n\n2. **Clasificación de documentos** :\n\n * El usuario inicia el procesamiento a través de la interfaz de usuario\n * El backend recupera el contexto del documento de la memoria\n * El modelo clasificador de documentos determina el tipo de documento\n * El contexto se actualiza con la información del tipo de documento\n\n3. **Procesamiento de documentos** :\n\n * El enrutador del procesador selecciona el procesador apropiado según el tipo de documento\n * El procesador seleccionado (factura, contrato o correo electrónico) procesa el documento\n * El procesador utiliza Entity Extractor para identificar información clave\n * Los datos extraídos se agregan al contexto con puntajes de confianza.\n\n4. **Recuperación de resultados** :\n\n * El contexto actualizado se almacena nuevamente en la memoria\n * La interfaz de usuario recupera y muestra la información del documento procesado\n * El usuario puede ver los datos extraídos, los puntajes de confianza y el historial de procesamiento.\n\n5. **Auditoría y revisión** :\n\n * Todos los pasos del procesamiento se registran en el historial de procesamiento del contexto.\n * La interfaz de usuario proporciona visualización de puntuaciones de confianza para los datos extraídos\n * El usuario puede revisar el texto del documento junto con la información extraída\n\n## Empezando\n\n### Prerrequisitos\n\n* Python 3.8+\n* Node.js 14+ y npm (para el frontend)\n* Dependencias enumeradas en requirements.txt\n\n### Instalación y configuración\n\n#### Configuración del backend\n\n1. Clonar el repositorio\n\n ```bash\n git clone https://github.com/yourusername/mcp_document_processor.git\n cd mcp_document_processor\n ```\n\n2. Crear y activar un entorno virtual\n\n ```bash\n python -m venv venv\n source venv/bin/activate # On Windows: venv\\Scripts\\activate\n ```\n\n3. Instalar dependencias de backend\n\n ```bash\n pip install -r requirements.txt\n ```\n\n4. Crear un directorio de datos para el almacenamiento de documentos (si no existe)\n\n ```bash\n mkdir -p data\n ```\n\n#### Configuración de la interfaz\n\n1. Navegue hasta el directorio del frontend\n\n ```bash\n cd frontend\n ```\n\n2. Instalar dependencias del frontend\n\n ```bash\n npm install\n ```\n\n### Ejecutar la aplicación\n\n#### Iniciar el servidor backend\n\n1. Desde el directorio raíz del proyecto (con entorno virtual activado):\n\n ```bash\n python app.py\n ```\n\n Esto iniciará el servidor FastAPI en .\n\n2. Puede acceder a la documentación de la API en \n\n#### Iniciar el servidor de desarrollo frontend\n\n1. Abrir una nueva ventana/pestaña de terminal\n\n2. Navegue hasta el directorio del frontend:\n\n ```bash\n cd /path/to/mcp_document_processor/frontend\n ```\n\n3. Inicie el servidor de desarrollo de React:\n\n ```bash\n npm start\n ```\n\n Esto iniciará la interfaz en .\n\n### Uso de la aplicación\n\n1. Abra su navegador y navegue a \n2. Utilice la navegación de la barra lateral para:\n * Ver el panel de control\n * Subir nuevos documentos\n * Procesar y ver detalles del documento\n\n#### Ejemplo de flujo de trabajo\n\n1. **Subir un documento** :\n\n * Haga clic en \"Subir documento\" en la barra lateral.\n * Arrastre y suelte un documento (PDF, imagen o archivo de texto)\n * Haga clic en el botón \"Cargar documento\"\n\n2. **Procesar el documento** :\n\n * Después de cargar correctamente el documento, haga clic en \"Procesar documento\".\n * Espere a que se complete el procesamiento\n\n3. **Ver resultados** :\n\n * Ver datos extraídos, puntajes de confianza y el historial de procesamiento\n * Navegue al Panel de Control para ver todos los documentos procesados\n\n### Uso de la API\n\nTambién puedes interactuar directamente con la API:\n\n* `GET /api/documents` : Recuperar todos los documentos\n* `POST /api/documents/upload` : Subir un nuevo documento\n* `POST /api/documents/{document_id}/process` : Procesar un documento\n* `GET /api/documents/{document_id}` : Obtener detalles del documento\n* `DELETE /api/documents/{document_id}` : Eliminar un documento\n\n## Ampliación del sistema\n\n### Agregar un nuevo procesador de documentos\n\n1. Cree una nueva clase de procesador que herede de `BaseProcessor`\n2. Implementar los métodos `can_handle` y `process`\n3. Agregue el procesador al enrutador en `api/routes.py`\n\n### Agregar un nuevo modelo\n\n1. Cree una nueva clase de modelo que implemente el protocolo apropiado\n2. Agregar configuración en `config/config.yaml`\n3. Integrar el modelo con el procesador relevante\n\n## Licencia\n\n[Licencia MIT](LICENSE)","Spanish","es-ES",{"_29":48,"_33":52,"_38":53},{"_31":49,"_33":50,"_35":51},"モデルコンテキストプロトコル (MCP) を使用して、ビジネスドキュメントを自動的に分類、情報抽出、ルーティングするインテリジェントなドキュメント処理システム。","MCPドキュメントプロセッサ","# MCPドキュメントプロセッサ\n\nモデルコンテキストプロトコル (MCP) を使用してビジネスドキュメントを自動的に抽出、分析、ルーティングするインテリジェントなドキュメント処理システム。\n\n## プロジェクト概要\n\nこのプロジェクトでは、MCPを用いて実際のビジネス課題であるドキュメント処理ワークフローの自動化を解決する方法を示します。このシステムは以下のことが可能です。\n\n* 受信文書（請求書、契約書、メール）を分類する\n* MLモデルを使用して関連情報を抽出する\n* ドキュメントの種類に応じて処理し、処理パイプライン全体でコンテキストを維持し、REST API を通じて機能を公開します。\n\n## 主要なMCPコンポーネント\n\n* **コンテキストオブジェクト**: MCP の中心となるこれらのオブジェクト ( `MCPContext`で実装) は、処理ステップ間で情報を伝達し、ドキュメントの状態を維持します。\n* **メモリシステム**: プラグ可能なバックエンドを使用して、処理ステップ間のコンテキストオブジェクトを保存します。\n* **プロトコル**: プロセッサとモデルの明確なインターフェースを定義し、モジュール性を保証します。\n* **ルーター**: コンテンツに基づいてドキュメントを専門のプロセッサにインテリジェントにルーティングします。\n\n## ビジネス価値\n\nこのソリューションは、次のようないくつかのビジネス上の課題に対処します。\n\n* 手作業の削減: 文書からのデータ抽出を自動化\n* 一貫性: ドキュメントの種類を問わず一貫した処理を保証します\n* 監査可能性: 処理履歴と信頼スコアを維持する\n* 拡張性: モジュール設計により、新しいドキュメントタイプを簡単に追加できます。\n\n## 技術的なハイライト\n\n* 分類とエンティティ抽出にBERTベースのモデルを使用する\n* 文書要約のためのT5モデル\n* RESTインターフェース用のFastAPI\n* 簡単に拡張できるプラグ可能なアーキテクチャ\n* 包括的なログ記録とエラー処理\n* より良いユーザーエクスペリエンスを実現するReactベースのUI\n\n## 概要\n\nMCPドキュメントプロセッサは、請求書、契約書、電子メールなど、様々な種類のドキュメントを一貫性と自動化をもって処理するという、ビジネスにおける一般的な課題を解決するために設計されています。モデルコンテキストプロトコルフレームワークを活用し、システムの様々なコンポーネント間の情報フローを管理します。\n\n## 主な特徴\n\n* **文書分類**: 文書の種類を自動的に識別します\n* **情報抽出**: 文書から重要な情報を抽出します\n* **ドキュメントルーティング**: 適切なプロセッサにドキュメントをルーティングします\n* **コンテキスト管理**: 処理パイプライン全体でコンテキストを維持します\n* **APIインターフェース**:他のシステムとの統合のためのRESTful APIを提供します\n\n## 建築\n\nこのシステムは、以下を提供するモデルコンテキストプロトコル (MCP) を中心に構築されています。\n\n1. **コンテキストオブジェクト**: 処理ステップ間で情報を伝達する\n\n ```python\n # Example of MCPContext usage\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n\n # Adding extracted data with confidence scores\n context.add_extracted_data(\"invoice_number\", \"INV-12345\", confidence=0.95)\n\n # Tracking processing history\n context.add_to_history(\n processor_name=\"InvoiceProcessor\",\n status=\"completed\",\n details={\"processing_time\": \"0.5s\"}\n )\n ```\n\n2. **メモリシステム**: API呼び出し間のコンテキストオブジェクトを保存します\n\n ```python\n # Storing context in memory\n memory.store(document_id, context)\n\n # Retrieving context from memory\n context = memory.retrieve(document_id)\n ```\n\n3. **プロトコル**: プロセッサとモデルのインターフェースを定義する\n\n ```python\n # Processor protocol example\n class Processor(Protocol):\n @abstractmethod\n def process(self, context: MCPContext) -> MCPContext:\n \"\"\"Process the document and update the context.\"\"\"\n pass\n \n @abstractmethod\n def can_handle(self, context: MCPContext) -> bool:\n \"\"\"Determine if this processor can handle the given document.\"\"\"\n pass\n ```\n\n4. **ルーター**: 適切な専門プロセッサにドキュメントをルーティングします\n\n ```python\n # Router usage example\n processor = processor_router.route(context)\n if processor:\n processed_context = processor.process(context)\n ```\n\n### MCPフロー図\n\n```\nDocument Upload → MCPContext Creation → Memory Storage → \nDocument Processing → Router Selection → Specialized Processor → \nEntity Extraction → Context Update → Memory Storage → API Response\n```\n\n## MCP実装の詳細\n\nこのプロジェクトにおけるモデルコンテキストプロトコルの実装には、いくつかの重要な利点があります。\n\n### 1. コンテキストの永続性を備えたステートフル処理\n\n`MCPContext`クラスは、ドキュメント処理ライフサイクル全体にわたって状態を維持します。\n\n```python\n# Context is created during document upload\n@router.post(\"/documents/upload\")\nasync def upload_document(file: UploadFile, memory: MemoryInterface):\n # Create a context\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n \n # Store in memory for later retrieval\n memory.store(document_id, context)\n```\n\n### 2. プラガブルメモリシステム\n\nメモリシステムはプラグ可能に設計されており、さまざまなストレージバックエンドを可能にします。\n\n```python\n# Factory function in memory.py\ndef get_memory_store(memory_type: str = \"in_memory\", **kwargs) -> MemoryInterface:\n if memory_type == \"in_memory\":\n return InMemoryStorage(default_ttl=kwargs.get(\"ttl\", 3600))\n # Additional implementations can be added here\n```\n\n### 3. 信頼度の追跡\n\nMCP は抽出されたすべてのデータの信頼スコアを追跡し、より適切な意思決定を可能にします。\n\n```python\n# In entity_extractor.py\nentity_data = {\n \"text\": text[current_entity[\"start\"]:current_entity[\"end\"]],\n \"start\": current_entity[\"start\"],\n \"end\": current_entity[\"end\"],\n \"confidence\": avg_confidence\n}\n```\n\n### 4. 処理履歴\n\n各処理ステップはコンテキストの履歴に記録され、監査可能性を実現します。\n\n```python\n# In router.py\ncontext.add_to_history(\n processor_name=processor.__class__.__name__,\n status=\"completed\"\n)\n```\n\n### 5. インテリジェントなドキュメントルーティング\n\n`ProcessorRouter` 、各ドキュメントに適切なプロセッサを決定します。\n\n```python\n# In router.py\ndef route(self, context: MCPContext) -> Optional[Processor]:\n for processor in self.processors:\n if processor.can_handle(context):\n return processor\n return None\n```\n\n### 6. 拡張性\n\n`Processor`プロトコルを実装すると、新しいドキュメントタイプを簡単に追加できます。\n\n```python\n# Example of adding a new processor\nclass NewDocumentProcessor(BaseProcessor):\n def can_handle(self, context: MCPContext) -> bool:\n # Logic to determine if this processor can handle the document\n pass\n \n def process(self, context: MCPContext) -> MCPContext:\n # Document processing logic\n pass\n```\n\n## ドキュメントプロセッサ\n\nシステムには、さまざまなドキュメントタイプ専用のプロセッサが含まれています。\n\n* **請求書プロセッサ**: ベンダー、顧客、明細項目、合計などを抽出します。\n* **契約プロセッサ**: 当事者、重要な日付、条件などを抽出します。\n* **電子メールプロセッサ**: 送信者、受信者、件名、本文などを抽出します。\n\n## 機械学習モデル\n\nさまざまなタスクに複数の ML モデルが使用されます。\n\n* **文書分類器**: 文書タイプ分類のためのBERTベースのモデル\n* **エンティティ抽出器**: 重要な情報を抽出するための固有表現抽出モデル\n* **サマライザー**: 文書要約を生成するためのT5ベースのモデル\n\n## ユーザーインターフェース\n\nMCP Document Processorには、ドキュメント処理システムを直感的に操作できるReactベースの最新ユーザーインターフェースが搭載されています。UIはMaterial-UIで構築されており、以下の機能を提供します。\n\n### UI機能\n\n* **ダッシュボード**: 処理されたドキュメントの概要、統計情報、ドキュメントの詳細へのクイックアクセス\n* **ドキュメントのアップロード**: 新しいドキュメントをアップロードするためのドラッグアンドドロップインターフェース\n* **文書処理**：文書を処理するためのステップバイステップのワークフロー\n* **ドキュメントビューア**: 抽出された情報を含む処理済みドキュメントの詳細表示\n* **処理履歴**: 監査可能性のためにすべての処理ステップをタイムラインで表示します\n\n### UIアーキテクチャ\n\nフロントエンドは以下で構築されています:\n\n* **React** : ユーザーインターフェースコンポーネントの構築用\n* **Material-UI** : 一貫性のあるレスポンシブなデザイン\n* **React Router** : 異なるビュー間のナビゲーション用\n* **Axios** : バックエンドとのAPI通信用\n* **Chart.js** : ドキュメント統計のデータ視覚化\n\n### UI-バックエンド統合\n\nフロントエンドは、次の主要なエンドポイントを使用して、RESTful API を介してバックエンドと通信します。\n\n* `GET /api/documents` : すべてのドキュメントを取得する\n* `POST /api/documents/upload` : 新しいドキュメントをアップロードする\n* `POST /api/documents/{document_id}/process` : ドキュメントを処理する\n* `GET /api/documents/{document_id}` : ドキュメントの詳細を取得する\n* `DELETE /api/documents/{document_id}` : ドキュメントを削除する\n\n## 完全なシステムアーキテクチャ\n\nMCP ドキュメントプロセッサは、フロントエンド、API レイヤー、処理コンポーネント、機械学習モデルを統合した階層型アーキテクチャに従います。\n\n```\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Frontend Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Dashboard │ │ Upload │ │ Document Viewer │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ API Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Document │ │ Document │ │\n│ │ Upload API │ │ Process API │ │ Retrieval API │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ MCP Core Components │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ MCPContext │◄────►│ Memory │◄────►│ Processor Router │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │\n└──────────┼────────────────────────────────────────────┼─────────────────┘\n │ │\n │ │\n ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Document Processors │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Invoice │ │ Contract │ │ Email │ │\n│ │ Processor │ │ Processor │ │ Processor │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ ML Models Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Entity │ │ Summarizer │ │\n│ │ Classifier │ │ Extractor │ │ │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────────┘\n```\n\n## 完全なワークフロー\n\nドキュメント処理ワークフローには、システムコンポーネント全体にわたる複数のステップが含まれます。\n\n1. **ドキュメントのアップロード**:\n\n * ユーザーはUIを通じてドキュメントをアップロードします\n * フロントエンドはドキュメントをバックエンドAPIに送信します\n * バックエンドはドキュメントメタデータを持つMCPContextオブジェクトを作成します\n * コンテキストはメモリシステムに保存されます\n\n2. **文書分類**:\n\n * ユーザーはUIを通じて処理を開始する\n * バックエンドはメモリからドキュメントのコンテキストを取得します\n * ドキュメント分類モデルはドキュメントの種類を決定します\n * コンテキストはドキュメントタイプ情報で更新されます\n\n3. **文書処理**：\n\n * プロセッサルータはドキュメントの種類に基づいて適切なプロセッサを選択します\n * 選択されたプロセッサ（請求書、契約書、または電子メール）がドキュメントを処理します\n * プロセッサはエンティティ抽出器を使用して重要な情報を識別する\n * 抽出されたデータは信頼スコアとともにコンテキストに追加されます\n\n4. **結果取得**:\n\n * 更新されたコンテキストはメモリに保存されます\n * UIは処理された文書情報を取得して表示します\n * ユーザーは抽出されたデータ、信頼スコア、処理履歴を表示できます。\n\n5. **監査とレビュー**：\n\n * すべての処理手順はコンテキストの処理履歴に記録されます\n * UIは抽出されたデータの信頼スコアの視覚化を提供します\n * ユーザーは抽出された情報と一緒に文書のテキストを確認することができます\n\n## はじめる\n\n### 前提条件\n\n* Python 3.8以上\n* Node.js 14+ と npm (フロントエンド用)\n* requirements.txt にリストされている依存関係\n\n### インストールとセットアップ\n\n#### バックエンドのセットアップ\n\n1. リポジトリをクローンする\n\n ```bash\n git clone https://github.com/yourusername/mcp_document_processor.git\n cd mcp_document_processor\n ```\n\n2. 仮想環境を作成してアクティブ化する\n\n ```bash\n python -m venv venv\n source venv/bin/activate # On Windows: venv\\Scripts\\activate\n ```\n\n3. バックエンドの依存関係をインストールする\n\n ```bash\n pip install -r requirements.txt\n ```\n\n4. ドキュメント保存用のデータディレクトリを作成します（存在しない場合）\n\n ```bash\n mkdir -p data\n ```\n\n#### フロントエンドのセットアップ\n\n1. フロントエンドディレクトリに移動する\n\n ```bash\n cd frontend\n ```\n\n2. フロントエンドの依存関係をインストールする\n\n ```bash\n npm install\n ```\n\n### アプリケーションの実行\n\n#### バックエンドサーバーを起動する\n\n1. プロジェクトのルートディレクトリから (仮想環境が有効になっている):\n\n ```bash\n python app.py\n ```\n\n これにより[、 http://localhost:8000](http://localhost:8000)で FastAPI サーバーが起動します。\n\n2. APIドキュメント[はhttp://localhost:8000/docs](http://localhost:8000/docs)からアクセスできます。\n\n#### フロントエンド開発サーバーを起動する\n\n1. 新しいターミナルウィンドウ/タブを開く\n\n2. フロントエンドディレクトリに移動します。\n\n ```bash\n cd /path/to/mcp_document_processor/frontend\n ```\n\n3. React 開発サーバーを起動します。\n\n ```bash\n npm start\n ```\n\n これにより[、 http://localhost:3000](http://localhost:3000)でフロントエンドが起動します。\n\n### アプリケーションの使用\n\n1. ブラウザを開き、にアクセスします。\n2. サイドバーナビゲーションを使用して次の操作を実行します。\n * ダッシュボードを見る\n * 新しい文書をアップロードする\n * ドキュメントの詳細を処理して表示する\n\n#### ワークフローの例\n\n1. **ドキュメントをアップロード**:\n\n * サイドバーの「ドキュメントをアップロード」をクリックします\n * ドキュメント（PDF、画像、またはテキストファイル）をドラッグアンドドロップします\n * 「ドキュメントをアップロード」ボタンをクリックします\n\n2. **ドキュメントを処理する**:\n\n * アップロードが成功したら、「ドキュメントを処理」をクリックします。\n * 処理が完了するまでお待ちください\n\n3. **結果を表示**:\n\n * 抽出されたデータ、信頼スコア、処理履歴を表示する\n * ダッシュボードに移動して、処理済みのすべてのドキュメントを確認します。\n\n### APIの使用\n\nAPI と直接やり取りすることもできます。\n\n* `GET /api/documents` : すべてのドキュメントを取得する\n* `POST /api/documents/upload` : 新しいドキュメントをアップロードする\n* `POST /api/documents/{document_id}/process` : ドキュメントを処理する\n* `GET /api/documents/{document_id}` : ドキュメントの詳細を取得する\n* `DELETE /api/documents/{document_id}` : ドキュメントを削除する\n\n## システムの拡張\n\n### 新しいドキュメントプロセッサの追加\n\n1. `BaseProcessor`を継承する新しいプロセッサクラスを作成する\n2. `can_handle`と`process`メソッドを実装する\n3. `api/routes.py`でルーターにプロセッサを追加します。\n\n### 新しいモデルの追加\n\n1. 適切なプロトコルを実装する新しいモデルクラスを作成する\n2. `config/config.yaml`に設定を追加する\n3. モデルを関連プロセッサと統合する\n\n## ライセンス\n\n[MITライセンス](LICENSE)","Japanese","ja-JP",{"_29":55,"_33":59,"_38":60},{"_31":56,"_33":57,"_35":58},"모델 컨텍스트 프로토콜(MCP)을 사용하여 비즈니스 문서를 자동으로 분류하고, 정보를 추출하고, 라우팅하는 지능형 문서 처리 시스템입니다.","MCP 문서 프로세서","# MCP 문서 프로세서\n\n모델 컨텍스트 프로토콜(MCP)을 사용하여 비즈니스 문서를 자동으로 추출, 분석, 라우팅하는 지능형 문서 처리 시스템입니다.\n\n## 프로젝트 개요\n\n이 프로젝트는 MCP를 사용하여 실제 비즈니스 과제인 문서 처리 워크플로 자동화를 해결하는 방법을 보여줍니다. 이 시스템은 다음과 같은 기능을 제공합니다.\n\n* 수신 문서(송장, 계약서, 이메일)를 분류합니다.\n* ML 모델을 사용하여 관련 정보 추출\n* 문서 유형에 따라 처리 처리 파이프라인 전체에서 컨텍스트 유지 REST API를 통해 기능 노출\n\n## 주요 MCP 구성 요소\n\n* **컨텍스트 개체** : MCP의 핵심인 이 개체( `MCPContext` 에 구현됨)는 처리 단계 간에 정보를 전달하고 문서의 상태를 유지합니다.\n* **메모리 시스템** : 플러그 가능한 백엔드를 사용하여 처리 단계 사이의 컨텍스트 객체를 저장합니다.\n* **프로토콜** : 프로세서와 모델에 대한 명확한 인터페이스를 정의하여 모듈성을 보장합니다.\n* **라우터** : 콘텐츠에 따라 문서를 전문 프로세서로 지능적으로 라우팅합니다.\n\n## 사업적 가치\n\n이 솔루션은 다음과 같은 여러 가지 비즈니스 과제를 해결합니다.\n\n* 수동 처리 감소: 문서에서 데이터 추출을 자동화합니다.\n* 일관성: 문서 유형 전반에 걸쳐 일관된 처리를 보장합니다.\n* 감사 가능성: 처리 내역 및 신뢰도 점수를 유지합니다.\n* 확장성: 모듈식 디자인으로 새로운 문서 유형을 쉽게 추가할 수 있습니다.\n\n## 기술적 하이라이트\n\n* 분류 및 엔터티 추출을 위해 BERT 기반 모델을 사용합니다.\n* 문서 요약을 위한 T5 모델\n* REST 인터페이스를 위한 FastAPI\n* 간편한 확장을 위한 플러그형 아키텍처\n* 포괄적인 로깅 및 오류 처리\n* 더 나은 사용자 경험을 위한 React 기반 UI\n\n## 개요\n\nMCP 문서 처리기는 다양한 유형의 문서(송장, 계약서, 이메일 등)를 일관되고 자동화된 방식으로 처리하는 일반적인 비즈니스 과제를 해결하도록 설계되었습니다. MCP는 모델 컨텍스트 프로토콜(Model Context Protocol) 프레임워크를 활용하여 시스템의 여러 구성 요소 간의 정보 흐름을 관리합니다.\n\n## 주요 특징\n\n* **문서 분류** : 문서 유형을 자동으로 식별합니다.\n* **정보 추출** : 문서에서 핵심 정보를 추출합니다.\n* **문서 라우팅** : 문서를 적절한 프로세서로 라우팅합니다.\n* **컨텍스트 관리** : 처리 파이프라인 전체에서 컨텍스트를 유지합니다.\n* **API 인터페이스** : 다른 시스템과의 통합을 위한 RESTful API를 제공합니다.\n\n## 건축학\n\n이 시스템은 다음을 제공하는 모델 컨텍스트 프로토콜(MCP)을 중심으로 구축되었습니다.\n\n1. **컨텍스트 객체** : 처리 단계 전반에 걸쳐 정보를 전달합니다.\n\n 지엑스피1\n\n2. **메모리 시스템** : API 호출 간 컨텍스트 객체를 저장합니다.\n\n ```python\n # Storing context in memory\n memory.store(document_id, context)\n\n # Retrieving context from memory\n context = memory.retrieve(document_id)\n ```\n\n3. **프로토콜** : 프로세서 및 모델에 대한 인터페이스 정의\n\n ```python\n # Processor protocol example\n class Processor(Protocol):\n @abstractmethod\n def process(self, context: MCPContext) -> MCPContext:\n \"\"\"Process the document and update the context.\"\"\"\n pass\n \n @abstractmethod\n def can_handle(self, context: MCPContext) -> bool:\n \"\"\"Determine if this processor can handle the given document.\"\"\"\n pass\n ```\n\n4. **라우터** : 문서를 적절한 전문 프로세서로 라우팅합니다.\n\n ```python\n # Router usage example\n processor = processor_router.route(context)\n if processor:\n processed_context = processor.process(context)\n ```\n\n### MCP 흐름도\n\n```\nDocument Upload → MCPContext Creation → Memory Storage → \nDocument Processing → Router Selection → Specialized Processor → \nEntity Extraction → Context Update → Memory Storage → API Response\n```\n\n## MCP 구현 세부 정보\n\n이 프로젝트의 모델 컨텍스트 프로토콜 구현은 여러 가지 주요 이점을 제공합니다.\n\n### 1. 컨텍스트 지속성을 갖춘 상태 저장 처리\n\n`MCPContext` 클래스는 문서 처리 라이프사이클 전체에 걸쳐 상태를 유지합니다.\n\n```python\n# Context is created during document upload\n@router.post(\"/documents/upload\")\nasync def upload_document(file: UploadFile, memory: MemoryInterface):\n # Create a context\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n \n # Store in memory for later retrieval\n memory.store(document_id, context)\n```\n\n### 2. 플러그형 메모리 시스템\n\n메모리 시스템은 플러그형으로 설계되어 다양한 스토리지 백엔드를 사용할 수 있습니다.\n\n```python\n# Factory function in memory.py\ndef get_memory_store(memory_type: str = \"in_memory\", **kwargs) -> MemoryInterface:\n if memory_type == \"in_memory\":\n return InMemoryStorage(default_ttl=kwargs.get(\"ttl\", 3600))\n # Additional implementations can be added here\n```\n\n### 3. 신뢰도 추적\n\nMCP는 추출된 모든 데이터에 대한 신뢰도 점수를 추적하여 더 나은 의사 결정을 내릴 수 있도록 합니다.\n\n```python\n# In entity_extractor.py\nentity_data = {\n \"text\": text[current_entity[\"start\"]:current_entity[\"end\"]],\n \"start\": current_entity[\"start\"],\n \"end\": current_entity[\"end\"],\n \"confidence\": avg_confidence\n}\n```\n\n### 4. 처리 내역\n\n각 처리 단계는 컨텍스트의 기록에 기록되어 감사가 가능합니다.\n\n```python\n# In router.py\ncontext.add_to_history(\n processor_name=processor.__class__.__name__,\n status=\"completed\"\n)\n```\n\n### 5. 지능형 문서 라우팅\n\n`ProcessorRouter` 각 문서에 적합한 프로세서를 결정합니다.\n\n```python\n# In router.py\ndef route(self, context: MCPContext) -> Optional[Processor]:\n for processor in self.processors:\n if processor.can_handle(context):\n return processor\n return None\n```\n\n### 6. 확장성\n\n`Processor` 프로토콜을 구현하면 새로운 문서 유형을 간단하게 추가할 수 있습니다.\n\n```python\n# Example of adding a new processor\nclass NewDocumentProcessor(BaseProcessor):\n def can_handle(self, context: MCPContext) -> bool:\n # Logic to determine if this processor can handle the document\n pass\n \n def process(self, context: MCPContext) -> MCPContext:\n # Document processing logic\n pass\n```\n\n## 문서 처리기\n\n이 시스템에는 다양한 문서 유형에 대한 전문 프로세서가 포함되어 있습니다.\n\n* **송장 처리기** : 공급업체, 고객, 품목, 총액 등을 추출합니다.\n* **계약 처리기** : 당사자, 주요 날짜, 조건 등을 추출합니다.\n* **이메일 프로세서** : 발신자, 수신자, 제목, 본문 등을 추출합니다.\n\n## 머신 러닝 모델\n\n다양한 작업에 여러 ML 모델이 사용됩니다.\n\n* **문서 분류기** : 문서 유형 분류를 위한 BERT 기반 모델\n* **엔티티 추출기** : 주요 정보를 추출하기 위한 명명된 엔티티 인식 모델\n* **요약기** : 문서 요약을 생성하기 위한 T5 기반 모델\n\n## 사용자 인터페이스\n\nMCP 문서 처리기는 문서 처리 시스템과 직관적으로 상호작용할 수 있는 현대적인 React 기반 사용자 인터페이스를 제공합니다. UI는 Material-UI로 구축되었으며 다음과 같은 기능을 제공합니다.\n\n### UI 기능\n\n* **대시보드** : 통계를 포함한 처리된 문서 개요 및 문서 세부 정보에 대한 빠른 액세스\n* **문서 업로드** : 새 문서 업로드를 위한 드래그 앤 드롭 인터페이스\n* **문서 처리** : 문서 처리를 위한 단계별 워크플로\n* **문서 뷰어** : 추출된 정보가 포함된 처리된 문서의 자세한 보기\n* **처리 내역** : 감사를 위한 모든 처리 단계의 타임라인 보기\n\n### UI 아키텍처\n\n프런트엔드는 다음으로 구성됩니다.\n\n* **React** : 사용자 인터페이스 구성 요소를 구축하기 위해\n* **Material-UI** : 일관되고 반응성 있는 디자인을 위해\n* **React Router** : 다양한 뷰 간 탐색을 위해\n* **Axios** : 백엔드와의 API 통신을 위해\n* **Chart.js** : 문서 통계의 데이터 시각화를 위한 도구\n\n### UI 백엔드 통합\n\n프런트엔드는 RESTful API를 통해 백엔드와 통신하며, 주요 엔드포인트는 다음과 같습니다.\n\n* `GET /api/documents` : 모든 문서 검색\n* `POST /api/documents/upload` : 새 문서 업로드\n* `POST /api/documents/{document_id}/process` : 문서 처리\n* `GET /api/documents/{document_id}` : 문서 세부 정보 가져오기\n* `DELETE /api/documents/{document_id}` : 문서 삭제\n\n## 완전한 시스템 아키텍처\n\nMCP 문서 프로세서는 프런트엔드, API 계층, 처리 구성 요소 및 머신 러닝 모델을 통합하는 계층형 아키텍처를 따릅니다.\n\n```\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Frontend Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Dashboard │ │ Upload │ │ Document Viewer │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ API Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Document │ │ Document │ │\n│ │ Upload API │ │ Process API │ │ Retrieval API │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ MCP Core Components │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ MCPContext │◄────►│ Memory │◄────►│ Processor Router │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │\n└──────────┼────────────────────────────────────────────┼─────────────────┘\n │ │\n │ │\n ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Document Processors │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Invoice │ │ Contract │ │ Email │ │\n│ │ Processor │ │ Processor │ │ Processor │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ ML Models Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Entity │ │ Summarizer │ │\n│ │ Classifier │ │ Extractor │ │ │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────────┘\n```\n\n## 전체 워크플로\n\n문서 처리 워크플로는 시스템 구성 요소 전반에 걸쳐 여러 단계로 구성됩니다.\n\n1. **문서 업로드** :\n\n * 사용자는 UI를 통해 문서를 업로드합니다.\n * 프런트엔드가 문서를 백엔드 API로 보냅니다.\n * 백엔드는 문서 메타데이터를 사용하여 MCPContext 객체를 생성합니다.\n * 컨텍스트는 메모리 시스템에 저장됩니다.\n\n2. **문서 분류** :\n\n * 사용자는 UI를 통해 처리를 시작합니다.\n * 백엔드는 메모리에서 문서 컨텍스트를 검색합니다.\n * 문서 분류기 모델은 문서 유형을 결정합니다.\n * 컨텍스트는 문서 유형 정보로 업데이트됩니다.\n\n3. **문서 처리** :\n\n * 프로세서 라우터는 문서 유형에 따라 적절한 프로세서를 선택합니다.\n * 선택된 프로세서(송장, 계약서 또는 이메일)가 문서를 처리합니다.\n * 프로세서는 엔티티 추출기를 사용하여 주요 정보를 식별합니다.\n * 추출된 데이터는 신뢰도 점수와 함께 컨텍스트에 추가됩니다.\n\n4. **결과 검색** :\n\n * 업데이트된 컨텍스트는 메모리에 다시 저장됩니다.\n * UI는 처리된 문서 정보를 검색하여 표시합니다.\n * 사용자는 추출된 데이터, 신뢰도 점수 및 처리 기록을 볼 수 있습니다.\n\n5. **감사 및 검토** :\n\n * 모든 처리 단계는 컨텍스트의 처리 기록에 기록됩니다.\n * UI는 추출된 데이터에 대한 신뢰도 점수를 시각화합니다.\n * 사용자는 추출된 정보와 함께 문서 텍스트를 검토할 수 있습니다.\n\n## 시작하기\n\n### 필수 조건\n\n* 파이썬 3.8 이상\n* Node.js 14+ 및 npm(프런트엔드용)\n* requirements.txt에 나열된 종속성\n\n### 설치 및 설정\n\n#### 백엔드 설정\n\n1. 저장소를 복제합니다\n\n ```bash\n git clone https://github.com/yourusername/mcp_document_processor.git\n cd mcp_document_processor\n ```\n\n2. 가상 환경을 생성하고 활성화합니다\n\n ```bash\n python -m venv venv\n source venv/bin/activate # On Windows: venv\\Scripts\\activate\n ```\n\n3. 백엔드 종속성 설치\n\n ```bash\n pip install -r requirements.txt\n ```\n\n4. 문서 저장을 위한 데이터 디렉토리를 생성합니다(존재하지 않는 경우)\n\n ```bash\n mkdir -p data\n ```\n\n#### 프런트엔드 설정\n\n1. 프런트엔드 디렉토리로 이동합니다\n\n ```bash\n cd frontend\n ```\n\n2. 프런트엔드 종속성 설치\n\n ```bash\n npm install\n ```\n\n### 애플리케이션 실행\n\n#### 백엔드 서버 시작\n\n1. 프로젝트의 루트 디렉토리에서(가상 환경이 활성화된 상태에서):\n\n ```bash\n python app.py\n ```\n\n 이렇게 하면 에서 FastAPI 서버가 시작됩니다.\n\n2. 에서 API 문서에 액세스할 수 있습니다.\n\n#### 프런트엔드 개발 서버 시작\n\n1. 새 터미널 창/탭을 엽니다\n\n2. 프런트엔드 디렉토리로 이동합니다.\n\n ```bash\n cd /path/to/mcp_document_processor/frontend\n ```\n\n3. React 개발 서버를 시작합니다.\n\n ```bash\n npm start\n ```\n\n 이렇게 하면 에서 프런트엔드가 시작됩니다.\n\n### 애플리케이션 사용\n\n1. 브라우저를 열고 으로 이동하세요.\n2. 사이드바 탐색을 사용하여 다음을 수행하세요.\n * 대시보드 보기\n * 새 문서 업로드\n * 문서 세부 정보 처리 및 보기\n\n#### 워크플로 예시\n\n1. **문서 업로드** :\n\n * 사이드바에서 \"문서 업로드\"를 클릭하세요\n * 문서(PDF, 이미지 또는 텍스트 파일)를 끌어서 놓으세요\n * \"문서 업로드\" 버튼을 클릭하세요\n\n2. **문서 처리** :\n\n * 업로드가 성공적으로 완료되면 \"문서 처리\"를 클릭하세요.\n * 처리가 완료될 때까지 기다리세요\n\n3. **결과보기** :\n\n * 추출된 데이터, 신뢰도 점수 및 처리 내역 보기\n * 대시보드로 이동하여 처리된 모든 문서를 확인하세요.\n\n### API 사용\n\nAPI와 직접 상호 작용할 수도 있습니다.\n\n* `GET /api/documents` : 모든 문서 검색\n* `POST /api/documents/upload` : 새 문서 업로드\n* `POST /api/documents/{document_id}/process` : 문서 처리\n* `GET /api/documents/{document_id}` : 문서 세부 정보 가져오기\n* `DELETE /api/documents/{document_id}` : 문서 삭제\n\n## 시스템 확장\n\n### 새 문서 프로세서 추가\n\n1. `BaseProcessor` 에서 상속되는 새로운 프로세서 클래스를 만듭니다.\n2. `can_handle` 및 `process` 메서드를 구현합니다.\n3. `api/routes.py` 에서 라우터에 프로세서를 추가합니다.\n\n### 새 모델 추가\n\n1. 적절한 프로토콜을 구현하는 새로운 모델 클래스를 만듭니다.\n2. `config/config.yaml` 에 구성을 추가합니다.\n3. 모델을 관련 프로세서와 통합합니다.\n\n## 특허\n\n[MIT 라이센스](LICENSE)","Korean","ko-KR",{"_29":62,"_33":66,"_38":67},{"_31":63,"_33":64,"_35":65},"一种智能文档处理系统，使用模型上下文协议 (MCP) 自动对业务文档进行分类、提取信息和路由。","MCP文档处理器","# MCP文档处理器\n\n使用模型上下文协议 (MCP) 自动提取、分析和路由业务文档的智能文档处理系统。\n\n## 项目概述\n\n该项目演示了如何使用 MCP 解决实际业务挑战：自动化文档处理工作流程。该系统可以：\n\n* 对收到的文件（发票、合同、电子邮件）进行分类\n* 使用机器学习模型提取相关信息\n* 根据文档类型进行处理在整个处理流程中维护上下文通过 REST API 公开功能\n\n## 关键 MCP 组件\n\n* **上下文对象**：MCP 的核心，这些对象（在`MCPContext`中实现）在处理步骤之间传递信息并维护文档的状态。\n* **内存系统**：存储处理步骤之间的上下文对象，并带有可插入的后端。\n* **协议**：为处理器和模型定义清晰的接口，确保模块化。\n* **路由器**：根据内容智能地将文档路由到专门的处理器。\n\n## 商业价值\n\n该解决方案解决了几个业务挑战：\n\n* 减少手动处理：自动从文档中提取数据\n* 一致性：确保跨文档类型的一致处理\n* 可审计性：维护处理历史和置信度分数\n* 可扩展性：模块化设计允许轻松添加新的文档类型\n\n## 技术亮点\n\n* 使用基于 BERT 的模型进行分类和实体提取\n* T5 文档摘要模型\n* 用于 REST 接口的 FastAPI\n* 可插拔架构，易于扩展\n* 全面的日志记录和错误处理\n* 基于 React 的 UI 可提供更好的用户体验\n\n## 概述\n\nMCP 文档处理器旨在解决以一致且自动化的方式处理各种类型文档（发票、合同、电子邮件等）的常见业务挑战。它利用模型上下文协议框架来管理系统不同组件之间的信息流。\n\n## 主要特点\n\n* **文档分类**：自动识别文档类型\n* **信息提取**：从文档中提取关键信息\n* **文档路由**：将文档路由到适当的处理器\n* **上下文管理**：在整个处理流程中维护上下文\n* **API 接口**：提供 RESTful API 以便与其他系统集成\n\n## 建筑学\n\n该系统围绕模型上下文协议 (MCP) 构建，该协议提供：\n\n1. **上下文对象**：跨处理步骤传递信息\n\n ```python\n # Example of MCPContext usage\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n\n # Adding extracted data with confidence scores\n context.add_extracted_data(\"invoice_number\", \"INV-12345\", confidence=0.95)\n\n # Tracking processing history\n context.add_to_history(\n processor_name=\"InvoiceProcessor\",\n status=\"completed\",\n details={\"processing_time\": \"0.5s\"}\n )\n ```\n\n2. **内存系统**：存储 API 调用之间的上下文对象\n\n ```python\n # Storing context in memory\n memory.store(document_id, context)\n\n # Retrieving context from memory\n context = memory.retrieve(document_id)\n ```\n\n3. **协议**：定义处理器和模型的接口\n\n ```python\n # Processor protocol example\n class Processor(Protocol):\n @abstractmethod\n def process(self, context: MCPContext) -> MCPContext:\n \"\"\"Process the document and update the context.\"\"\"\n pass\n \n @abstractmethod\n def can_handle(self, context: MCPContext) -> bool:\n \"\"\"Determine if this processor can handle the given document.\"\"\"\n pass\n ```\n\n4. **路由器**：将文档路由到适当的专用处理器\n\n ```python\n # Router usage example\n processor = processor_router.route(context)\n if processor:\n processed_context = processor.process(context)\n ```\n\n### MCP流程图\n\n```\nDocument Upload → MCPContext Creation → Memory Storage → \nDocument Processing → Router Selection → Specialized Processor → \nEntity Extraction → Context Update → Memory Storage → API Response\n```\n\n## MCP 实现细节\n\n该项目中的模型上下文协议实现具有几个主要优势：\n\n### 1. 具有上下文持久性的状态处理\n\n`MCPContext`类在整个文档处理生命周期中维护状态：\n\n```python\n# Context is created during document upload\n@router.post(\"/documents/upload\")\nasync def upload_document(file: UploadFile, memory: MemoryInterface):\n # Create a context\n context = MCPContext(\n document_id=document_id,\n raw_text=text,\n metadata=metadata\n )\n \n # Store in memory for later retrieval\n memory.store(document_id, context)\n```\n\n### 2. 可插拔内存系统\n\n内存系统设计为可插拔的，允许不同的存储后端：\n\n```python\n# Factory function in memory.py\ndef get_memory_store(memory_type: str = \"in_memory\", **kwargs) -> MemoryInterface:\n if memory_type == \"in_memory\":\n return InMemoryStorage(default_ttl=kwargs.get(\"ttl\", 3600))\n # Additional implementations can be added here\n```\n\n### 3. 信心追踪\n\nMCP 跟踪所有提取数据的置信度分数，从而实现更好的决策：\n\n```python\n# In entity_extractor.py\nentity_data = {\n \"text\": text[current_entity[\"start\"]:current_entity[\"end\"]],\n \"start\": current_entity[\"start\"],\n \"end\": current_entity[\"end\"],\n \"confidence\": avg_confidence\n}\n```\n\n### 4. 处理历史记录\n\n每个处理步骤都记录在上下文的历史记录中，提供可审计性：\n\n```python\n# In router.py\ncontext.add_to_history(\n processor_name=processor.__class__.__name__,\n status=\"completed\"\n)\n```\n\n### 5.智能文档路由\n\n`ProcessorRouter`为每个文档确定适当的处理器：\n\n```python\n# In router.py\ndef route(self, context: MCPContext) -> Optional[Processor]:\n for processor in self.processors:\n if processor.can_handle(context):\n return processor\n return None\n```\n\n### 6.可扩展性\n\n通过实现`Processor`协议，可以轻松添加新的文档类型：\n\n```python\n# Example of adding a new processor\nclass NewDocumentProcessor(BaseProcessor):\n def can_handle(self, context: MCPContext) -> bool:\n # Logic to determine if this processor can handle the document\n pass\n \n def process(self, context: MCPContext) -> MCPContext:\n # Document processing logic\n pass\n```\n\n## 文件处理器\n\n该系统包括针对不同文档类型的专用处理器：\n\n* **发票处理器**：提取供应商、客户、明细项目、总计等。\n* **合同处理器**：提取当事人、关键日期、条款等。\n* **电子邮件处理器**：提取发件人、收件人、主题、正文等。\n\n## 机器学习模型\n\n有几种 ML 模型可用于不同的任务：\n\n* **文档分类器**：基于 BERT 的文档类型分类模型\n* **实体提取器**：用于提取关键信息的命名实体识别模型\n* **Summarizer** ：基于T5的文档摘要生成模型\n\n## 用户界面\n\nMCP 文档处理器包含一个基于 React 的现代用户界面，该界面提供了与文档处理系统直观的交互方式。该 UI 使用 Material-UI 构建，并提供以下功能：\n\n### UI 功能\n\n* **仪表板**：已处理文档的概览，包含统计数据并可快速访问文档详细信息\n* **文档上传**：用于上传新文档的拖放界面\n* **文档处理**：处理文档的分步工作流程\n* **文档查看器**：查看已处理文档的详细视图以及提取的信息\n* **处理历史**：所有处理步骤的时间线视图，方便审计\n\n### UI架构\n\n前端构建如下：\n\n* **React** ：用于构建用户界面组件\n* **Material-UI** ：一致的响应式设计\n* **React Router** ：用于不同视图之间的导航\n* **Axios** ：用于与后端进行 API 通信\n* **Chart.js** ：用于文档统计的数据可视化\n\n### UI-后端集成\n\n前端通过 RESTful API 与后端通信，主要端点如下：\n\n* `GET /api/documents` ：检索所有文档\n* `POST /api/documents/upload` ：上传新文档\n* `POST /api/documents/{document_id}/process` ：处理文档\n* `GET /api/documents/{document_id}` ：获取文档详细信息\n* `DELETE /api/documents/{document_id}` ：删除文档\n\n## 完整的系统架构\n\nMCP 文档处理器遵循分层架构，集成了前端、API 层、处理组件和机器学习模型：\n\n```\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Frontend Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Dashboard │ │ Upload │ │ Document Viewer │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ API Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Document │ │ Document │ │\n│ │ Upload API │ │ Process API │ │ Retrieval API │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ MCP Core Components │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ MCPContext │◄────►│ Memory │◄────►│ Processor Router │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │\n└──────────┼────────────────────────────────────────────┼─────────────────┘\n │ │\n │ │\n ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ Document Processors │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Invoice │ │ Contract │ │ Email │ │\n│ │ Processor │ │ Processor │ │ Processor │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │ │ │ │\n└──────────┼───────────────────┼─────────────────────────┼────────────────┘\n │ │ │\n │ │ │\n ▼ ▼ ▼\n┌─────────────────────────────────────────────────────────────────────────┐\n│ ML Models Layer │\n│ │\n│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │\n│ │ Document │ │ Entity │ │ Summarizer │ │\n│ │ Classifier │ │ Extractor │ │ │ │\n│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────────┘\n```\n\n## 完整的工作流程\n\n文档处理工作流程涉及系统组件的多个步骤：\n\n1. **文件上传**：\n\n * 用户通过 UI 上传文档\n * 前端将文档发送到后端 API\n * 后端使用文档元数据创建 MCPContext 对象\n * 上下文存储在记忆系统中\n\n2. **文件分类**：\n\n * 用户通过 UI 启动处理\n * 后端从内存中检索文档上下文\n * 文档分类器模型确定文档类型\n * 使用文档类型信息更新上下文\n\n3. **文件处理**：\n\n * 处理器路由器根据文档类型选择适当的处理器\n * 选定的处理器（发票、合同或电子邮件）处理文档\n * 处理器使用实体提取器识别关键信息\n * 提取的数据与置信度分数一起添加到上下文中\n\n4. **结果检索**：\n\n * 更新后的上下文存储回内存\n * UI检索并显示处理后的文档信息\n * 用户可以查看提取的数据、置信度分数和处理历史记录\n\n5. **审计与审查**：\n\n * 所有处理步骤都记录在上下文的处理历史记录中\n * UI 提供提取数据的置信度分数的可视化\n * 用户可以查看文档文本以及提取的信息\n\n## 入门\n\n### 先决条件\n\n* Python 3.8+\n* Node.js 14+ 和 npm（用于前端）\n* requirements.txt 中列出的依赖项\n\n### 安装和设置\n\n#### 后端设置\n\n1. 克隆存储库\n\n ```bash\n git clone https://github.com/yourusername/mcp_document_processor.git\n cd mcp_document_processor\n ```\n\n2. 创建并激活虚拟环境\n\n ```bash\n python -m venv venv\n source venv/bin/activate # On Windows: venv\\Scripts\\activate\n ```\n\n3. 安装后端依赖项\n\n ```bash\n pip install -r requirements.txt\n ```\n\n4. 创建用于文档存储的数据目录（如果不存在）\n\n ```bash\n mkdir -p data\n ```\n\n#### 前端设置\n\n1. 导航到前端目录\n\n ```bash\n cd frontend\n ```\n\n2. 安装前端依赖项\n\n ```bash\n npm install\n ```\n\n### 运行应用程序\n\n#### 启动后端服务器\n\n1. 从项目的根目录（激活虚拟环境）：\n\n ```bash\n python app.py\n ```\n\n 这将在上启动 FastAPI 服务器。\n\n2. 您可以通过访问 API 文档\n\n#### 启动前端开发服务器\n\n1. 打开一个新的终端窗口/选项卡\n\n2. 导航到前端目录：\n\n ```bash\n cd /path/to/mcp_document_processor/frontend\n ```\n\n3. 启动 React 开发服务器：\n\n ```bash\n npm start\n ```\n\n 这将在上启动前端。\n\n### 使用应用程序\n\n1. 打开浏览器并导航至\n2. 使用侧边栏导航可以：\n * 查看仪表板\n * 上传新文件\n * 处理并查看文档详细信息\n\n#### 示例工作流程\n\n1. **上传文件**：\n\n * 点击侧边栏中的“上传文档”\n * 拖放文档（PDF、图像或文本文件）\n * 点击“上传文档”按钮\n\n2. **处理文件**：\n\n * 上传成功后，点击“处理文档”\n * 等待处理完成\n\n3. **查看结果**：\n\n * 查看提取的数据、置信度分数和处理历史记录\n * 导航到仪表板查看所有已处理的文档\n\n### API 使用\n\n您还可以直接与 API 进行交互：\n\n* `GET /api/documents` ：检索所有文档\n* `POST /api/documents/upload` ：上传新文档\n* `POST /api/documents/{document_id}/process` ：处理文档\n* `GET /api/documents/{document_id}` ：获取文档详细信息\n* `DELETE /api/documents/{document_id}` ：删除文档\n\n## 扩展系统\n\n### 添加新的文档处理器\n\n1. 创建一个继承自`BaseProcessor`新处理器类\n2. 实现`can_handle`和`process`方法\n3. 在`api/routes.py`处理器添加到路由器\n\n### 添加新模型\n\n1. 创建一个新的模型类，实现适当的协议\n2. 在`config/config.yaml`中添加配置\n3. 将模型与相关处理器集成\n\n## 执照\n\n[MIT 许可证](LICENSE)","Chinese","zh-CN","githubUser","locale",{"_71":72,"_73":74,"_13":81,"_84":32,"_85":32,"_86":87,"_90":91,"_113":-5,"_16":114,"_115":116,"_117":118,"_33":34,"_157":104,"_158":-5,"_159":-5,"_160":-5,"_161":-5,"_162":163,"_168":-5,"_125":100,"_169":-5,"_170":-5,"_105":171,"_172":173},"addedAt",["D",1746234072742],"argumentsJsonSchema",{"_75":76,"_77":78,"_79":80},"properties",{},"required",[],"type","object",[82,83],"language:python","license_grade:a","descriptionMarkdown","descriptionPlainText","githubProject",{"_35":36,"_88":89},"url","https://github.com/arifazim/MCP_Document_Classifer","githubRepository",{"_92":93,"_94":95,"_96":97,"_98":99,"_33":100,"_101":102,"_107":108,"_109":110,"_112":108},"defaultBranch","main","fullName","arifazim/MCP_Document_Classifer","githubTreeId",114156,"language","Python","MCP_Document_Classifer","owner",{"_103":104,"_105":106},"login","arifazim","uid","Eszkbkad89","recentStargazers",0,"spdxLicense",{"_33":111},"GPL 3.0","stargazers","glamaJson",6233,"inspectable",false,"integrations",[119,129,136,143,150],{"_120":121,"_31":127,"_105":128},"brand",{"_122":123,"_33":124,"_125":126},"logoSvgPath","M11.0683 2.89968V22.2973l-2.11399 1.70265V7.8638H4.975l6.0933-4.96412zM14.93426 0v15.76724H19.025l-6.20044 5.08865V1.4689L14.93426 0z","Axios","slug","axios","Used for API communication between the frontend and backend, enabling efficient HTTP requests for document processing workflows.","v9ucb1tzub",{"_120":130,"_31":134,"_105":135},{"_122":131,"_33":132,"_125":133},"M12 0L1.605 6v12L12 24l10.395-6V6zm0 1.41l9.172 5.295v10.59L12 22.59l-9.172-5.295V6.705zM5.902 8.334c-1.306 0-1.983.956-2.574 2.41v6.262L12 22.014l8.672-5.008v-5.971c-.447-.264-.894-.412-1.336-.412-4.275 0-3.97 4.885-6.717 5.8-2.748.917-3.511-8.089-6.717-8.089zm12.364.457c-2.9 0-2.137 4.732-5.342 4.732-1.63 0-2.52-1.317-3.477-1.981.148.326.3.655.442.98.467 1.068.922 2.09 1.379 2.734.228.322.455.541.644.644a.595.595 0 0 0 .549.05c.558-.187.968-.571 1.36-1.112.39-.541.74-1.228 1.154-1.916.413-.688.894-1.385 1.59-1.918.695-.534 1.607-.881 2.77-.881.465 0 .908.136 1.337.352v-.121c-.633-.849-1.348-1.563-2.406-1.563zm-6.68.152c-.868 0-1.491.82-2.076 2.06.094.055.192.106.277.167 1.06.761 1.798 1.853 3.137 1.853.678 0 1.067-.218 1.418-.585-.722-1.546-1.432-3.492-2.756-3.495Z","Chart.js","chartdotjs","Integrates with the UI for data visualization of document statistics, providing graphical representation of document processing metrics.","g9g2z5t1on",{"_120":137,"_31":141,"_105":142},{"_122":138,"_33":139,"_125":140},"M12 .0387C5.3729.0384.0003 5.3931 0 11.9988c-.001 6.6066 5.372 11.9628 12 11.9625 6.628.0003 12.001-5.3559 12-11.9625-.0003-6.6057-5.3729-11.9604-12-11.96m-.829 5.4153h7.55l-7.5805 5.3284h5.1828L5.279 18.5436q2.9466-6.5444 5.892-13.0896","FastAPI","fastapi","Powers the REST interface for the document processing system, enabling API-based interactions with the document processing capabilities.","iksgfia99b",{"_120":144,"_31":148,"_105":149},{"_122":145,"_33":146,"_125":147},"M14.23 12.004a2.236 2.236 0 0 1-2.235 2.236 2.236 2.236 0 0 1-2.236-2.236 2.236 2.236 0 0 1 2.235-2.236 2.236 2.236 0 0 1 2.236 2.236zm2.648-10.69c-1.346 0-3.107.96-4.888 2.622-1.78-1.653-3.542-2.602-4.887-2.602-.41 0-.783.093-1.106.278-1.375.793-1.683 3.264-.973 6.365C1.98 8.917 0 10.42 0 12.004c0 1.59 1.99 3.097 5.043 4.03-.704 3.113-.39 5.588.988 6.38.32.187.69.275 1.102.275 1.345 0 3.107-.96 4.888-2.624 1.78 1.654 3.542 2.603 4.887 2.603.41 0 .783-.09 1.106-.275 1.374-.792 1.683-3.263.973-6.365C22.02 15.096 24 13.59 24 12.004c0-1.59-1.99-3.097-5.043-4.032.704-3.11.39-5.587-.988-6.38-.318-.184-.688-.277-1.092-.278zm-.005 1.09v.006c.225 0 .406.044.558.127.666.382.955 1.835.73 3.704-.054.46-.142.945-.25 1.44-.96-.236-2.006-.417-3.107-.534-.66-.905-1.345-1.727-2.035-2.447 1.592-1.48 3.087-2.292 4.105-2.295zm-9.77.02c1.012 0 2.514.808 4.11 2.28-.686.72-1.37 1.537-2.02 2.442-1.107.117-2.154.298-3.113.538-.112-.49-.195-.964-.254-1.42-.23-1.868.054-3.32.714-3.707.19-.09.4-.127.563-.132zm4.882 3.05c.455.468.91.992 1.36 1.564-.44-.02-.89-.034-1.345-.034-.46 0-.915.01-1.36.034.44-.572.895-1.096 1.345-1.565zM12 8.1c.74 0 1.477.034 2.202.093.406.582.802 1.203 1.183 1.86.372.64.71 1.29 1.018 1.946-.308.655-.646 1.31-1.013 1.95-.38.66-.773 1.288-1.18 1.87-.728.063-1.466.098-2.21.098-.74 0-1.477-.035-2.202-.093-.406-.582-.802-1.204-1.183-1.86-.372-.64-.71-1.29-1.018-1.946.303-.657.646-1.313 1.013-1.954.38-.66.773-1.286 1.18-1.868.728-.064 1.466-.098 2.21-.098zm-3.635.254c-.24.377-.48.763-.704 1.16-.225.39-.435.782-.635 1.174-.265-.656-.49-1.31-.676-1.947.64-.15 1.315-.283 2.015-.386zm7.26 0c.695.103 1.365.23 2.006.387-.18.632-.405 1.282-.66 1.933-.2-.39-.41-.783-.64-1.174-.225-.392-.465-.774-.705-1.146zm3.063.675c.484.15.944.317 1.375.498 1.732.74 2.852 1.708 2.852 2.476-.005.768-1.125 1.74-2.857 2.475-.42.18-.88.342-1.355.493-.28-.958-.646-1.956-1.1-2.98.45-1.017.81-2.01 1.085-2.964zm-13.395.004c.278.96.645 1.957 1.1 2.98-.45 1.017-.812 2.01-1.086 2.964-.484-.15-.944-.318-1.37-.5-1.732-.737-2.852-1.706-2.852-2.474 0-.768 1.12-1.742 2.852-2.476.42-.18.88-.342 1.356-.494zm11.678 4.28c.265.657.49 1.312.676 1.948-.64.157-1.316.29-2.016.39.24-.375.48-.762.705-1.158.225-.39.435-.788.636-1.18zm-9.945.02c.2.392.41.783.64 1.175.23.39.465.772.705 1.143-.695-.102-1.365-.23-2.006-.386.18-.63.406-1.282.66-1.933zM17.92 16.32c.112.493.2.968.254 1.423.23 1.868-.054 3.32-.714 3.708-.147.09-.338.128-.563.128-1.012 0-2.514-.807-4.11-2.28.686-.72 1.37-1.536 2.02-2.44 1.107-.118 2.154-.3 3.113-.54zm-11.83.01c.96.234 2.006.415 3.107.532.66.905 1.345 1.727 2.035 2.446-1.595 1.483-3.092 2.295-4.11 2.295-.22-.005-.406-.05-.553-.132-.666-.38-.955-1.834-.73-3.703.054-.46.142-.944.25-1.438zm4.56.64c.44.02.89.034 1.345.034.46 0 .915-.01 1.36-.034-.44.572-.895 1.095-1.345 1.565-.455-.47-.91-.993-1.36-1.565z","React","react","Provides the foundation for the user interface components, enabling interactive document viewing and processing capabilities.","pwsfycmkmk",{"_120":151,"_31":155,"_105":156},{"_122":152,"_33":153,"_125":154},"M12.118 5.466a2.306 2.306 0 00-.623.08c-.278.067-.702.332-.953.583-.41.423-.49.609-.662 1.469-.08.423.41 1.43.847 1.734.45.317 1.085.502 2.065.608 1.429.16 1.84.636 1.84 2.197 0 1.377-.385 1.747-1.96 1.906-1.707.172-2.58.834-2.765 2.117-.106.781.41 1.76 1.125 2.091 1.627.768 3.15-.198 3.467-2.196.211-1.284.622-1.642 1.998-1.747 1.588-.133 2.409-.675 2.713-1.787.278-1.02-.304-2.157-1.297-2.554-.264-.106-.873-.238-1.35-.291-1.495-.16-1.879-.424-2.038-1.39-.225-1.337-.317-1.562-.794-2.09a2.174 2.174 0 00-1.613-.73zm-4.785 4.36a2.145 2.145 0 00-.497.048c-1.469.318-2.17 2.051-1.35 3.295 1.178 1.774 3.944.953 3.97-1.177.012-1.193-.98-2.143-2.123-2.166zM2.089 14.19a2.22 2.22 0 00-.427.052c-2.158.476-2.237 3.626-.106 4.182.53.145.582.145 1.111.013 1.191-.318 1.866-1.456 1.549-2.607-.278-1.02-1.144-1.664-2.127-1.64zm19.824.008c-.233.002-.477.058-.784.162-1.39.477-1.866 2.092-.98 3.336.557.794 1.96 1.058 2.82.516 1.416-.874 1.363-3.057-.093-3.746-.38-.186-.663-.271-.963-.268z","React Router","react-router","Enables navigation between different views in the document processing UI, supporting the complete document workflow.","p0db3xt6rj","namespace","npmPackage","prompts","redditPostForeignId","resources","scores",{"_164":165,"_166":-5,"_167":-5},"license",100,"quality","security","simpleIcon","supportedPlatforms","tools","3bjbgpxsfc","updatedAt",["D",1746234094369],"meta",[176,179,181,188,191,193,196,199,202,205,208,210,213,216,218,220,222,224,226],{"_177":178},"title","MCP Document Processor | Glama",{"_180":32,"_33":31},"content",{"_182":183,"_184":185,"_186":187},"href","https://glama.ai/mcp/servers/@arifazim/MCP_Document_Classifer","rel","canonical","tagName","link",{"_180":34,"_189":190},"property","og:title",{"_180":32,"_189":192},"og:description",{"_180":194,"_189":195},"https://glama.ai/logo.png","og:logo",{"_180":197,"_189":198},"https://glama.ai/mcp/servers/@arifazim/MCP_Document_Classifer/og-image","og:image",{"_180":200,"_189":201},"630","og:image:height",{"_180":203,"_189":204},"1200","og:image:width",{"_180":206,"_189":207},"website","og:type",{"_180":183,"_189":209},"og:url",{"_180":211,"_189":212},"Glama – MCP Hosting Platform","og:site_name",{"_180":214,"_33":215},"summary_large_image","twitter:card",{"_180":211,"_33":217},"twitter:title",{"_180":32,"_33":219},"twitter:description",{"_180":197,"_33":221},"twitter:image",{"_180":200,"_33":223},"twitter:image:height",{"_180":203,"_33":225},"twitter:image:width",{"_227":228},"script:ld+json",{"_229":230,"_231":232},"@context","http://schema.org","@graph",[233],{"_229":234,"_235":236,"_237":238},"https://schema.org","@type","BreadcrumbList","itemListElement",[239,246,250,254],{"_235":240,"_241":242,"_33":243,"_244":245},"ListItem","item","https://glama.ai/","Glama","position",1,{"_235":240,"_241":247,"_33":248,"_244":249},"https://glama.ai/mcp","MCP",2,{"_235":240,"_241":251,"_33":252,"_244":253},"https://glama.ai/mcp/servers","Servers",3,{"_235":240,"_241":183,"_33":34,"_244":255},4,"visitorIsMaintainer","routes/_public/mcp/servers/~namespace/~slug/_pages/reviews/_route",{"_68":-5,"_29":259,"_174":282,"_317":-5},{"_71":260,"_73":261,"_13":264,"_84":32,"_85":32,"_86":265,"_90":266,"_113":-5,"_16":114,"_115":116,"_117":269,"_33":34,"_157":104,"_158":-5,"_159":-5,"_160":-5,"_161":-5,"_162":280,"_168":-5,"_125":100,"_169":-5,"_170":-5,"_105":171,"_172":281},["D",1746234072742],{"_75":262,"_77":263,"_79":80},{},[],[82,83],{"_35":36,"_88":89},{"_92":93,"_94":95,"_96":97,"_98":99,"_33":100,"_101":267,"_107":108,"_109":268,"_112":108},{"_103":104,"_105":106},{"_33":111},[270,272,274,276,278],{"_120":271,"_31":127,"_105":128},{"_122":123,"_33":124,"_125":126},{"_120":273,"_31":134,"_105":135},{"_122":131,"_33":132,"_125":133},{"_120":275,"_31":141,"_105":142},{"_122":138,"_33":139,"_125":140},{"_120":277,"_31":148,"_105":149},{"_122":145,"_33":146,"_125":147},{"_120":279,"_31":155,"_105":156},{"_122":152,"_33":153,"_125":154},{"_164":165,"_166":-5,"_167":-5},["D",1746234094369],[283,285,287,289,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305],{"_177":284},"Reviews | MCP Document Processor | Glama",{"_180":286,"_33":31},"Read community reviews and feedback for MCP Document Processor. Discover user experiences, ratings, strengths, and potential limitations of this MCP implementation from actual users.",{"_182":288,"_184":185,"_186":187},"https://glama.ai/mcp/servers/@arifazim/MCP_Document_Classifer/reviews",{"_180":290,"_189":190},"Reviews | MCP Document Processor",{"_180":286,"_189":192},{"_180":194,"_189":195},{"_180":197,"_189":198},{"_180":200,"_189":201},{"_180":203,"_189":204},{"_180":206,"_189":207},{"_180":288,"_189":209},{"_180":211,"_189":212},{"_180":214,"_33":215},{"_180":211,"_33":217},{"_180":286,"_33":219},{"_180":197,"_33":221},{"_180":200,"_33":223},{"_180":203,"_33":225},{"_227":306},{"_229":230,"_231":307},[308],{"_229":234,"_235":236,"_237":309},[310,311,312,313,314],{"_235":240,"_241":242,"_33":243,"_244":245},{"_235":240,"_241":247,"_33":248,"_244":249},{"_235":240,"_241":251,"_33":252,"_244":253},{"_235":240,"_241":183,"_33":34,"_244":255},{"_235":240,"_241":288,"_33":315,"_244":316},"Reviews",5,"review","actionData","errors"]

Rate & Review