Markitdown MCP kann jedes Dokument in Markdowns umwandeln!

Um Dokumente zu handeln, geht es nicht mehr nur darum, Dateien in Ihren KI -Projekten zu öffnen, sondern darum, das Chaos in Klarheit zu verwandeln. Dokumente wie PDFs, Powerpoints und Wort überfluten unsere Workflows in jeder Kind und Größe. Das Abrufen strukturierter Inhalte aus diesen Dokumenten ist heute zu einer großen Aufgabe geworden. Markitdown MCP (Markdown Conversion Protocol) von Microsoft vereinfacht dies. Es wandelt verschiedene Dateien in ein strukturiertes Markdown -Format um. Dies hilft Entwicklern und technischen Autoren, Dokumentationsworkflows zu verbessern. Dieser Artikel erklärt Markitdown MCP und zeigt seine Verwendung. Wir werden den Markitdown MCP -Server einrichten und Markitdown im Kontext dieses Protokolls diskutieren. Die Verwendung des Markitdown -MCP -Servers zum Testen wird auch unten behandelt.

Was ist Markitdown MCP?

Markitdown MCP bietet eine Standardmethode für die Konvertierung von Dokumenten. Es fungiert als serverseitiges Protokoll. Es verwendet Microsoft Markitdown -Bibliothek im Backend. Der Server hostet eine erholsame API. Benutzer senden Dokumente wie PDFs oder Phrase -Dateien an diesen Server. Der Server verarbeitet dann diese Dateien. Es verwendet erweiterte Parsen und spezifische Formatierungsregeln. Der Ausgang ist Markdown -Textual content, der die Unique -Dokumentstruktur aufbewahrt.

Schlüsselmerkmale von Markitdown MCP

Der Markitdown MCP Server enthält mehrere nützliche Funktionen:

• Unterstützung für breite Format: Sie konvertiert gemeinsame Dateien wie PDF, DOCX und PPTX in Markdown.
• Strukturschutz: Sie verwendet Methoden, um Dokumentlayouts wie Überschriften und Pay attention zu verstehen und zu verwalten.
• Konfigurierbare Ausgabe: Benutzer können Einstellungen anpassen, um den endgültigen Markdown -Stil zu steuern.
• Serverbetrieb: Es wird als Serverprozess ausgeführt. Dies ermöglicht die Integration in automatisierte Systeme und Cloud -Setups.

Die Rolle des Abschlusses bei Arbeitsabläufen

Markdown ist ein beliebtes Format für die Dokumentation. Seine einfache Syntax erleichtert das Lesen und Schreiben. Viele Plattformen wie Github unterstützen es intestine. Statische Website -Generatoren verwenden es häufig. Das Konvertieren anderer Formate in die manuelle Markierung braucht Zeit. Markitdown MCP automatisiert diese Konvertierung. Dies bietet klare Vorteile:

• Effiziente Inhaltsverhandlung: Quelldokumente in nutzbare Markdowns verwandeln.
• Konsequente Zusammenarbeit: Standardformat hilft Groups, an Dokumenten zusammenzuarbeiten.
• Prozessautomatisierung: Fügen Sie die Konvertierung von Dokumenten in größere automatisierte Workflows ein.

Einrichten des Markitdown MCP Servers zur Integration

Wir können den Markitdown -MCP -Server mit verschiedenen Purchasers wie Claude, Windsurf und Cursor mit Docker -Bild einrichten, wie in der erwähnt Github Repo. Aber hier erstellen wir einen lokalen MCP -Shopper mithilfe Langchains MCP -Adapter. Wir brauchen einen Auslauf des Servers, um ihn mit Langchain zu verwenden. Der Server unterstützt verschiedene laufende Modi.

Set up

Installieren Sie zunächst die erforderlichen Python -Pakete.

pip set up markitdown-mcp langchain langchain_mcp_adapters langgraph langchain_groq

Serverkonfiguration

Führen Sie den Markitdown -MCP -Server mit dem STDIO -Modus aus. Dieser Modus verbindet die Standardeingangs- und Ausgangsströme. Es funktioniert intestine für skriptbasierte Integration. Führen Sie direkt im Terminal Folgendes aus.

markitdown-mcp

Der Server wird mit einigen Warnungen ausgeführt.

Wir können auch den SSE-Modus (Server-Despatched Occasions) verwenden. Dieser Modus passt zu Webanwendungen oder langjährigen Verbindungen. Es ist auch nützlich, wenn Sie einen Markitdown -MCP -Server einrichten, um bestimmte Szenarien zu testen.

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

Wählen Sie den Modus aus, der zu Ihrem Integrationsplan passt. Die Verwendung des Servers zum lokalen Testen über STDIO ist häufig ein guter Begin. Wir empfehlen den StDIO -Modus für diesen Artikel.

Markdown -Konvertierung mit Markitdown MCP

Wir haben bereits behandelt, wie Sie in unserem vorherigen Weblog einen MCP -Server und einen Shopper -Setup mit Langchain erstellen können MCP -Clientserver mit Langchain.

In diesem Abschnitt wird nun angezeigt, wie Langchain mit dem Markitdown MCP -Server verwendet wird. Es automatisiert die Konvertierung einer PDF -Datei in Markdown. Das Beispiel verwendet das Lama -Modell von CRQ über Chatgroq. Stellen Sie sicher, dass Sie die COQ -API -Style als Umgebungsvariable einrichten oder direkt an Chatgroq weitergeben.

Schritt 1: Importieren Sie zuerst die erforderlichen Bibliotheken.

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

Schritt 2: Initialisieren Sie das COQ LLM, es ist kostenlos. Hier finden Sie den API -Schlüssel

Hier ist der COQ -API -Schlüssel: GROQ API -Schlüssel

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

Schritt 3: Konfigurieren Sie den MCP -Server

Wir verwenden StDioServerparameter und hier direkt das installierte Markitdown -MCP -Paket hier

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

Schritt 4: Definieren Sie nun die asynchrone Funktion

Dadurch wird der PDF -Pfad als Eingabe erfolgt, und die ClientSession beginnt mit der Kommunikation. load_mcp_tools bietet Funktionen für die Langchain -Interaktion mit Markitdown MCP. Dann wird ein React -Agent erstellt, es verwendet das Modell und die MCP -Instruments. Der Code erstellt eine Datei_uri für die PDF und sendet eine Eingabeaufforderung, in der der Agent aufgefordert wird, die Datei mit MCP zu konvertieren.

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

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

           # Load out there instruments
           instruments = await load_mcp_tools(session)
           print(f"Loaded Instruments: {(device.title for device in instruments)}")

           # Create ReAct agent
           agent = create_react_agent(mannequin, instruments)
           print("ReAct Agent Created.")

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

               "messages": (("person", f"Convert {file_uri} to markdown utilizing Markitdown MCP simply return the output from MCP server"))

           })

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

Schritt 5: Dieser Code ruft die Funktion run_conversion auf

Wir rufen und extrahieren Markdown aus der Antwort. Es speichert den Inhalt PDF.MD und druckt schließlich die Ausgabe im Terminal.

if __name__ == "__main__":

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

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

   print("nMarkdown Conversion Consequence:")
   print(end result)

Ausgabe

Voller Code

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

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

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

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

)

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

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

           print("MCP Session Initialized.")
           # Load out there instruments
           instruments = await load_mcp_tools(session)

           print(f"Loaded Instruments: {(device.title for device in instruments)}")
           # Create ReAct agent

           agent = create_react_agent(mannequin, instruments)
           print("ReAct Agent Created.")

           # Put together file URI (convert native path to file:// URI)

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

               "messages": (("person", f"Convert {file_uri} to markdown utilizing Markitdown MCP simply retrun the output from MCP server"))

           })

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

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

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

       f.write(end result)
   print("nMarkdown Conversion Consequence:")
   print(end result)

Untersuchung der Ausgabe

Das Skript generiert eine PDF.MD -Datei. Diese Datei enthält die Markdown -Model des Eingabe -PDF. Die Konversionsqualität hängt von der Struktur des Originaldokuments ab. Markitdown MCP bewahrt normalerweise Elemente wie::

• Überschriften (verschiedene Ebenen)
• Absatztext
• Pay attention (Bulleted und nummeriert)
• Tabellen (konvertiert in Markdown -Syntax)
• Codeblöcke

Ausgabe

Hier in der Ausgabe können wir sehen, dass es die Überschriften, Inhalte und den normalen Textual content im Markdown -Format erfolgreich abgerufen hat.

Das Ausführen eines lokalen Servers zum Testen hilft daher bei der Bewertung verschiedener Dokumenttypen.

Auch beobachten:

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

Praktische Anwendungsfälle in LLM -Pipelines

Das Integrieren von Markitdown MCP kann mehrere KI -Workflows verbessern:

• Wissensbasisgebäude: Dokumente in Markdown umwandeln. Nehmen Sie diesen Inhalt in Wissensbasen oder Lappensysteme ein.
• LLM -Inhaltsvorbereitung: Quelldateien in Markdown verwandeln. Bereiten Sie eine konsistente Eingabe für LLM -Zusammenfassung oder Analyseaufgaben vor.
• Dokumentdatenextraktion: Umwandeln Sie Dokumente mit Tabellen in Markdown. Dies vereinfacht die Parsen strukturierter Daten.
• Dokumentationsautomatisierung: Generieren Sie technische Handbücher. Konvertieren Sie Quelldateien wie Phrase -Dokumente in Markdown für statische Website -Generatoren.

Abschluss

Markitdown MCP bietet eine fähige serverbasierte Methode für die Dokumentenkonvertierung. Es behandelt mehrere Formate. Es erzeugt eine strukturierte Markdown -Ausgabe. Durch die Integration in LLMs können Sie die Automatisierung von Dokumentenverarbeitungsaufgaben. Dieser Ansatz unterstützt skalierbare Dokumentationspraktiken. Wenn Sie den Server zum Testen verwenden, wird die Bewertung unkompliziert. Markitdowns MCP wird am besten durch seine praktische Anwendung in diesen Workflows verstanden.

Erforschen Sie Markitdown MCP Github Repository Weitere Informationen.

Häufig gestellte Fragen

Hallo, ich bin Pankaj Singh Negi – Senior Content material Editor | Leidenschaftlich über das Geschichtenerzählen und das Erstellen überzeugender Erzählungen, die Ideen in einen wirkungsvollen Inhalt verwandeln. Ich liebe es, über die Technologie zu lesen, die unseren Lebensstil revolutioniert.