MarkItDown：通用文件到 Markdown 转换器——微软面向 LLM 流水线的开源工具 2026

pip install 'markitdown[all]'

pip install 'markitdown[pdf,docx,pptx]'

# Full installation with all format support
pip install 'markitdown[all]'

# Verify installation
markitdown --version

uv venv --python=3.12 .venv
source .venv/bin/activate
uv pip install 'markitdown[all]'

git clone git@github.com:microsoft/markitdown.git
cd markitdown
pip install -e 'packages/markitdown[all]'

# PDF support only
pip install 'markitdown[pdf]'

# Document suite
pip install 'markitdown[docx,pptx,xlsx]'

# Image + audio (includes OCR and speech recognition)
pip install 'markitdown[images,audio]'

docker pull ghcr.io/microsoft/markitdown:latest
docker run -v $(pwd):/data markitdown /data/document.pdf > output.md

from langchain_community.document_loaders import MarkItDownLoader

loader = MarkItDownLoader("report.pdf")
documents = loader.load()

for doc in documents:
    print(doc.page_content[:500])

from llama_index.readers.markitdown import MarkItDownReader

reader = MarkItDownReader()
documents = reader.load_data("presentation.pptx")

from unstructured.partition.auto import partition

# MarkItDown complements unstructured.io
# Use MarkItDown for clean Markdown output,
# unstructured for chunking and metadata extraction

from haystack.document_stores import InMemoryDocumentStore
from markitdown import MarkItDown

md = MarkItDown()
result = md.convert("annual_report.docx")

doc_store = InMemoryDocumentStore()
doc_store.write_documents([
    {"content": result.text_content, "metadata": result.metadata}
])

from markitdown import MarkItDown
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

# Convert file to Markdown
md = MarkItDown()
converted = md.convert("technical_spec.pdf")

# Split into chunks for embedding
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
)
chunks = splitter.split_text(converted.text_content)

# Create embeddings and store in vector DB
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_texts(chunks, embeddings)

# Query
results = vectorstore.similarity_search("What are the API rate limits?")

import glob
from markitdown import MarkItDown

md = MarkItDown()
contract_dir = "/contracts/2026/"

for filepath in glob.glob(f"{contract_dir}*.pdf"):
    result = md.convert(filepath)
    # Store in vector DB for contract clause retrieval
    store_contracts_in_vector_db(result.text_content, filepath)

from markitdown import MarkItDown
from pathlib import Path

papers_dir = Path("/research/papers/")
md = MarkItDown()

for paper in papers_dir.rglob("*"):
    if paper.suffix in ['.pdf', '.docx', '.pptx']:
        converted = md.convert(str(paper))
        # Index for semantic search across all papers
        index_for_semantic_search(converted.text_content, paper.stem)

from markitdown import MarkItDown
from markitdown.perceptual import PerceptualMarkdownConverter

class CustomFormatConverter(PerceptualMarkdownConverter):
    """Custom handler for .xyz proprietary format."""
    
    def accepts_file(self, filepath: str) -> bool:
        return filepath.endswith(".xyz")
    
    def convert(self, filepath: str) -> str:
        # Your custom parsing logic
        content = parse_xyz_file(filepath)
        return format_as_markdown(content)

# Register custom converter
md = MarkItDown()
md.register_converter(CustomFormatConverter())

from azure.ai.contentsynthesis import ContentUnderstandingClient
from azure.identity import DefaultAzureCredential

client = ContentUnderstandingClient(
    credential=DefaultAzureCredential()
)

# Use Azure's AI analyzers for enhanced extraction
# Sentiment, key phrases, entity recognition
# alongside MarkItDown's structural conversion

import concurrent.futures
from markitdown import MarkItDown
from pathlib import Path

def convert_single_file(filepath):
    md = MarkItDown()
    result = md.convert(str(filepath))
    output_path = Path("output") / f"{filepath.stem}.md"
    output_path.parent.mkdir(exist_ok=True)
    output_path.write_text(result.text_content)
    return str(output_path)

# Process 1000 files in parallel
files = list(Path("/documents").rglob("*"))
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
    results = list(executor.map(convert_single_file, files))

from markitdown import MarkItDown

md = MarkItDown()
result = md.convert("company_report.docx")

print("Title:", result.metadata.get("title"))
print("Author:", result.metadata.get("author"))
print("Created:", result.metadata.get("creation_date"))
print("Keywords:", result.metadata.get("keywords"))
print("Page Count:", result.metadata.get("page_count"))

from markitdown import MarkItDown

md = MarkItDown()
# Stream output to avoid loading entire file in memory
with open("output.md", "w") as f:
    for chunk in md.convert_stream("large_document.pdf"):
        f.write(chunk)