¡Markitdown MCP puede convertir cualquier documento en Markdowns!

Manejo de documentos ya no se tráfico solo de destapar archivos en sus proyectos de IA, se tráfico de mudar el caos en claridad. Docs como PDF, PowerPoints y Word inundan nuestros flujos de trabajo en cada forma y tamaño. Recuperar contenido estructurado de estos documentos se ha convertido en una gran tarea hoy. Markitdown MCP (Protocolo de conversión de Markdown) de Microsoft simplifica esto. Convierte varios archivos en formato de impresionado estructurado. Esto ayuda a los desarrolladores y escritores técnicos a mejorar los flujos de trabajo de documentación. Este artículo explica Markitdown MCP y muestra su uso. Cubriremos la configuración del servidor MarkitDown MCP y todavía discutiremos Markitdown en el contexto de este protocolo. El uso del servidor MarkitDown MCP para las pruebas todavía se cubre a continuación.

¿Qué es Markitdown MCP?

Markitdown MCP ofrece un método normalizado para la conversión de documentos. Actúa como un protocolo del banda del servidor. Utiliza Microsoft’s Biblioteca Markitdown en el backend. El servidor aloja una API RESTful. Los usuarios envían documentos como PDF o archivos de Word a este servidor. El servidor luego procesa estos archivos. Utiliza prospección progresista y reglas de formato específicas. La salida es un texto de Markdown que mantiene la estructura del documento llamativo.

Características secreto de Markitdown MCP

El servidor MarkitDown MCP incluye varias características efectos:

• Soporte de formato amplio: Convierte archivos comunes como PDF, DOCX y PPTX a Markdown.
• Preservación de la estructura: utiliza métodos para comprender y surtir diseños de documentos como encabezados y listas.
• Salida configurable: los usuarios pueden ajustar la configuración para controlar el estilo final de Markdown.
• Operación del servidor: se ejecuta como un proceso de servidor. Esto permite la integración en sistemas automatizados y configuraciones de nubes.

El papel de la reducción en los flujos de trabajo

Markdown es un formato popular para la documentación. Su sintaxis simple hace que sea hacedero de ojear y escribir. Muchas plataformas como GitHub lo admiten acertadamente. Los generadores de sitios estáticos a menudo lo usan. La conversión de otros formatos a Markdown lleva manualmente. Markitdown MCP automatizar esta conversión. Esto proporciona beneficios claros:

• Manejo de contenido apto: mudar los documentos de origen en una reducción útil.
• Colaboración consistente: el formato normalizado ayuda a los equipos a trabajar juntos en documentos.
• Automatización de procesos: incluya la conversión de documentos interiormente de flujos de trabajo automatizados más grandes.

Configuración del servidor MarkitDown MCP para la integración

Podemos configurar el servidor MarkitDown MCP con diferentes clientes como Claude, Windsurf, cursor usando Docker Image como se menciona en el Repositorio de Github. Pero aquí estaremos creando un cliente de MCP regional usando Adaptadores MCP de Langchain. Necesitamos que ejecute el servidor para usarlo con Langchain. El servidor admite diferentes modos de ejecución.

Instalación

Primero, instale los paquetes de Python requeridos.

pip install markitdown-mcp langchain langchain_mcp_adapters langgraph langchain_groq

Configuración del servidor

Ejecute el servidor MarkitDown MCP usando el modo STDIO. Este modo conecta las secuencias de entrada y salida normalizado. Funciona acertadamente para la integración basada en script. Ejecute directamente lo ulterior en el terminal.

markitdown-mcp

El servidor comenzará a ejecutarse con algunas advertencias.

Incluso podemos usar el modo SSE (eventos de servidor de servidor). Este modo se adapta a aplicaciones web o conexiones de larga duración. Incluso es útil al configurar un servidor MarkitDown MCP para probar escenarios específicos.

markitdown-mcp --sse --host 127.0.0.1 --port 3001

Seleccione el modo que se ajuste a su plan de integración. Usar el servidor para probar localmente a través de STDIO es a menudo un buen aparición. Recomendamos usar el modo STDIO para este artículo.

Conversión de Markdown con Markitdown MCP

Ya hemos cubierto cómo construir un servidor MCP y una configuración del cliente localmente usando Langchain en nuestro blog antecedente Servidor de clientes MCP usando langchain.

Ahora, esta sección muestra cómo usar Langchain con el servidor MarkitDown MCP. Automatiza la conversión de un archivo PDF a Markdown. El ejemplo emplea el maniquí de Fuego de Groq a través de Chatgroq. Asegúrese de configurar la tecla API Groq como una variable de entorno o pasarla directamente a Chatgroq.

Paso 1: Cuantía las bibliotecas necesarias primero.

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent
import asyncio
from langchain_groq import ChatGroq

Paso 2: Inicializa el Groq LLM, es de forma gratuita. Puedes encontrar la secreto API aquí

Aquí está la tecla API Groq: Interruptor de API de Groq

# Initialize Groq model
model = ChatGroq(model="meta-llama/llama-4-scout-17b-16e-instruct", api_key="YOUR_API_KEY")

Paso 3: Configurar el servidor MCP

Estamos utilizando stdioserverparameters y directamente utilizando el paquete Markitdown MCP instalado aquí

server_params = StdioServerParameters(
   command="markitdown-mcp",
   args=()  # No additional arguments needed for STDIO mode
)

Paso 4: Ahora, defina la función asincrónica

Esto tomará la ruta PDF a medida que la entrada, los clientes de clientes inicien la comunicación. load_mcp_tools proporciona funciones para la interacción Langchain con Markitdown MCP. Luego se crea un agente React, utiliza el maniquí y las herramientas MCP. El código crea un archivo_uri para el PDF y envía una solicitud pidiendo al agente que convierta el archivo usando MCP.

async def run_conversion(pdf_path: str):
   async with stdio_client(server_params) as (read, write):
       async with ClientSession(read, write) as session:

           await session.initialize()
           print("MCP Session Initialized.")

           # Load available tools
           tools = await load_mcp_tools(session)
           print(f"Loaded Tools: {(tool.name for tool in tools)}")

           # Create ReAct agent
           agent = create_react_agent(model, tools)
           print("ReAct Agent Created.")

           # Prepare file URI (convert regional path to file:// URI)
           file_uri = f"file://{pdf_path}"
           # Invoke agent with conversion request
           response = await agent.ainvoke({

               "messages": (("user", f"Convert {file_uri} to markdown using Markitdown MCP just return the output from MCP server"))

           })

           # Return the last message content
           return response("messages")(-1).content

Paso 5: Este código apasionamiento a la función run_conversion

Estamos llamando y extrayendo Markdown de la respuesta. Cuidador el contenido a PDF.MD y finalmente imprime la salida en el terminal.

if __name__ == "__main__":

   pdf_path = "/home/harsh/Downloads/LLM Evaluation.pptx.pdf"  # Use absolute path
   result = asyncio.run(run_conversion(pdf_path))

   with open("pdf.md", 'w') as f:
      f.write(result)

   print("nMarkdown Conversion Result:")
   print(result)

Producción

Código completo

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent

import asyncio
from langchain_groq import ChatGroq
# Initialize Groq model
model = ChatGroq(model="meta-llama/llama-4-scout-17b-16e-instruct", api_key="")
# Configure MCP server
server_params = StdioServerParameters(

   command="markitdown-mcp", 
   args=()  # No additional arguments needed for STDIO mode

)

async def run_conversion(pdf_path: str):
   async with stdio_client(server_params) as (read, write):

       async with ClientSession(read, write) as session:
           await session.initialize()

           print("MCP Session Initialized.")
           # Load available tools
           tools = await load_mcp_tools(session)

           print(f"Loaded Tools: {(tool.name for tool in tools)}")
           # Create ReAct agent

           agent = create_react_agent(model, tools)
           print("ReAct Agent Created.")

           # Prepare file URI (convert regional path to file:// URI)

           file_uri = f"file://{pdf_path}"
           # Invoke agent with conversion request
           response = await agent.ainvoke({

               "messages": (("user", f"Convert {file_uri} to markdown using Markitdown MCP just retrun the output from MCP server"))

           })

           # Return the last message content
           return response("messages")(-1).content

if __name__ == "__main__":
   pdf_path = "/home/harsh/Downloads/LLM Evaluation.pdf"  # Use absolute path

   result = asyncio.run(run_conversion(pdf_path))
   with open("pdf.md", 'w') as f:

       f.write(result)
   print("nMarkdown Conversion Result:")
   print(result)

Examinando la salida

El script genera un archivo pdf.md. Este archivo contiene la interpretación Markdown de la entrada PDF. La calidad de conversión depende de la estructura del documento llamativo. Markitdown MCP generalmente conserva rudimentos como:

• Encabezados (varios niveles)
• Texto de párrafo
• Listas (balas y numeradas)
• Tablas (convertidas en sintaxis de Markdown)
• Bloques de código

Producción

Aquí en la salida, podemos ver que recuperó con éxito los encabezados, el contenido y el texto corriente en formato de Markdown.

Por lo tanto, ejecutar un servidor regional para pruebas ayuda a evaluar diferentes tipos de documentos.

Incluso mira:

https://www.youtube.com/watch?v=lyfr7qusvssss

Casos de uso práctico en tuberías de LLM

La integración de Markitdown MCP puede mejorar varios flujos de trabajo de IA:

• Edificio de colchoneta de conocimiento: Convertir documentos en Markdown. Ingente este contenido en bases de conocimiento o sistemas de trapo.
• Preparación de contenido de LLM: Transforme los archivos de origen en Markdown. Prepare una entrada consistente para las tareas de prontuario o prospección de LLM.
• Documentar la procedencia de datos: Convertir documentos con tablas en Markdown. Esto simplifica los datos estructurados de prospección.
• Automatización de documentación: Originar manuales técnicos. Convierta archivos de origen como documentos de Word en Markdown para generadores de sitios estáticos.

Conclusión

Markitdown MCP proporciona un método capaz basado en servidor para la conversión de documentos. Maneja múltiples formatos. Produce salida de reducción estructurada. Integrarlo con LLM permite la automatización de tareas de procesamiento de documentos. Este enfoque admite prácticas de documentación escalables. El uso del servidor para la prueba hace que la evaluación sea directa. Markitdown’s MCP se entiende mejor a través de su aplicación destreza en estos flujos de trabajo.

Explorar el Repositorio de Github de Markitdown MCP Para más información.

Preguntas frecuentes