🌌 MarkItDown: A Comprehensive Guide for Converting Files to Markdown for Local LLM Integration

MarkItDown stands as a lightweight yet powerful Python utility designed to facilitate the conversion of a diverse range of file formats into Markdown. Developed by Microsoft, this tool addresses the increasing need for streamlined data preparation for Large Language Models (LLMs) and related text analysis pipelines.1 Its primary function is to transform complex document structures into the simple and widely accepted Markdown format, ensuring that essential content elements such as headings, lists, tables, and hyperlinks are preserved.3 While the output is often human-readable, the library’s core objective lies in providing a structured and easily parsable format that can be readily ingested by text analysis tools and, particularly, by LLMs.3

The utility demonstrates compatibility with an extensive list of file types, positioning it as a versatile component in various data processing workflows. These supported formats encompass commonly used document types like PDF (.pdf), PowerPoint (.pptx), Word (.docx), and Excel (.xlsx), alongside media formats including images (with the capability to extract EXIF metadata and perform Optical Character Recognition - OCR) and audio (with EXIF metadata extraction and speech transcription capabilities).1 Furthermore, MarkItDown supports web and data formats such as HTML (with specialized handling for platforms like Wikipedia), XML, JSON, and CSV, as well as archive formats like ZIP (allowing for recursive processing of contents), YouTube URLs (enabling transcription retrieval), and EPubs.1

The rationale behind MarkItDown’s focus on Markdown is rooted in the format’s inherent simplicity and its compatibility with modern LLMs.3 Markdown’s syntax is intentionally minimal, resulting in text that is very close to plain text, which LLMs can readily process.3 Prominent LLMs, such as OpenAI’s GPT-4o, exhibit a natural understanding of Markdown and often utilize it in their generated responses without explicit prompting.3 Moreover, the concise nature of Markdown conventions contributes to efficient token usage, a factor that can be significant in terms of processing cost and speed, although this might be less of a direct concern for users operating LLMs on a local server.3 By maintaining document structure through Markdown elements, MarkItDown ensures that LLMs receive not just raw text but also contextual information that enhances their ability to perform tasks like summarization and text analysis.5 The formatting elements within Markdown, such as bold and italics, further provide semantic cues that can guide an LLM’s understanding of the text’s importance and type.5

⚡ Installation Guide

To begin using MarkItDown, the recommended method for installation is via pip, the Python package installer.6 For users who require support for all the file formats that MarkItDown can handle, the most straightforward approach is to install the library along with all its optional dependencies using the command:

Bash

pip install markitdown[all]

This command ensures that all necessary external libraries for processing different file types are installed, providing a comprehensive and backward-compatible experience, as the library’s dependencies are now organized into optional feature groups.3

For users who are primarily interested in working with a specific subset of file formats, MarkItDown allows for the installation of dependencies tailored to those needs. This can lead to a more streamlined installation process and a smaller overall footprint. For instance, to install only the dependencies required for processing PDF files, the following command can be used:

Bash

pip install markitdown[pdf]

Similarly, dependencies for other formats can be installed individually:

• Word (DOCX): pip install markitdown[docx]

• PowerPoint (PPTX): pip install markitdown[pptx]

• Excel (XLSX): pip install markitdown[xlsx]

• Older Excel (XLS): pip install markitdown[xls]

• Outlook messages: pip install markitdown[outlook]

• Azure Document Intelligence: pip install markitdown[az-doc-intel]

• Audio transcription (wav and mp3): pip install markitdown[audio-transcription]

• YouTube video transcription: pip install markitdown[youtube-transcription].3

For developers or users who wish to work with the very latest version of the library, potentially including unreleased features or bug fixes, MarkItDown can be installed directly from its source code repository on GitHub.6 This process involves first cloning the repository to your local machine:

Bash

git clone git@github.com:microsoft/markitdown.git

After cloning, navigate into the newly created markitdown directory:

Bash

cd markitdown

Finally, install the library in editable mode along with all its dependencies using the command:

Bash

pip install -e packages/markitdown[all]

The -e flag installs the library in editable mode, which means that any changes made to the source code will be immediately reflected in the installed package without requiring reinstallation.6 This is particularly useful for developers who intend to contribute to the project or customize its functionality.

⚡ Basic Usage Examples

MarkItDown can be utilized both as a Python library within your scripts and as a command-line tool for quick conversions.1

⚡ Python API:

To use MarkItDown in a Python script, you first need to import the MarkItDown class from the markitdown module:

Python

from markitdown import MarkItDown

Next, you create an instance of this class:

Python

md = MarkItDown()

With an instance of MarkItDown created, you can then use the convert() method to process various file types. Here are some basic examples:

• Converting a TXT file: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“example.txt”) print(result.text_content)

Simple text files are expected to be converted directly to Markdown, with the original text content largely preserved.

• Converting a CSV file: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“data.csv”) print(result.text_content)

CSV files are typically transformed into Markdown tables, where each column is separated by a pipe (|) and a separator line consisting of hyphens is placed below the header row.

• Converting a JSON file: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“data.json”) print(result.text_content)

The Markdown representation of a JSON file might vary depending on its structure. Simple JSON structures might be converted to Markdown lists or tables, while more complex structures could be presented as Markdown code blocks to maintain their hierarchical format.

• Converting an HTML file: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“webpage.html”) print(result.text_content)

HTML files are parsed, and their content is converted to corresponding Markdown elements. MarkItDown’s ability to handle Wikipedia pages specifically suggests an intelligent approach to extracting meaningful content from standard web page layouts.

⚡ Command-Line Interface (CLI):

Once MarkItDown is installed, it can also be used directly from the command line for convenient file conversions.1 Here are some basic examples of its usage:

• Converting a PDF file: Bash markitdown document.pdf > output.md

This command takes the document.pdf file as input, converts it to Markdown, and redirects the output to a file named output.md.

• Specifying the output file using the -o option: Bash markitdown document.docx -o output.md

The -o option provides a more explicit way to define the name of the output file.

• Piping content to MarkItDown: Bash cat input.txt | markitdown > output.md

This demonstrates how you can pipe the content of a file (or the output of another command) directly to the MarkItDown tool for conversion, with the resulting Markdown being redirected to output.md. This allows for integration with other command-line utilities and scripting workflows.

⚡ Detailed File Type Conversion Examples

MarkItDown’s versatility extends to a wide array of specific file formats, each handled with considerations for its unique structure and content.

⚡ Microsoft Word (DOCX):

• Basic Conversion: Converting a DOCX file to Markdown is straightforward: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“report.docx”) print(result.text_content)

This process aims to preserve text formatting such as bold and italics, along with structural elements like headings, lists, and tables, in the resulting Markdown. MarkItDown likely employs libraries like mammoth to first convert the DOCX file to an intermediary HTML format, which is then further processed into Markdown.

• Handling Comments using style_map: To include comments from a DOCX document in the Markdown output, you can utilize the style_map parameter when initializing the MarkItDown object: Python from markitdown import MarkItDown style_map = “comment-reference => sup” md = MarkItDown(style_map=style_map) result = md.convert(“annotated_report.docx”) with open(“annotated_report.md”, “w”, encoding=‘utf-8’) as file: file.write(result.text_content)

By providing the style mapping “comment-reference => sup”, you instruct the underlying DOCX to HTML converter (mammoth) to render comments as superscript (^{) elements in the HTML. These superscript elements are then typically preserved in the subsequent conversion to Markdown.7 This demonstrates the library’s flexibility in allowing users to customize the conversion process for specific document features.}

⚡ Microsoft Excel (XLSX):

• Basic Conversion: Converting an Excel spreadsheet to Markdown can be done using the following code: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“spreadsheet.xlsx”) print(result.text_content)

Excel files are generally converted into Markdown tables. If the spreadsheet contains multiple sheets, each sheet is likely to be converted into a separate Markdown table within the output.2 MarkItDown probably uses libraries like pandas or openpyxl to read the data from the XLSX file and then formats it according to Markdown table syntax.

⚡ Microsoft PowerPoint (PPTX):

• Basic Conversion: To convert a PowerPoint presentation to Markdown: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“presentation.pptx”) print(result.text_content)

The conversion of PPTX files involves extracting the text content from slides, including titles, body text, speaker notes, and potentially annotations.8 This content is then formatted as Markdown, with slides often separated by headings or other clear markers. Libraries such as python-pptx are likely used to access the internal structure and content of the presentation file.

⚡ PDF Documents:

• Basic Conversion: Converting a PDF document to Markdown is similar to other file types: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“document.pdf”) print(result.text_content)

However, the success of PDF conversion heavily depends on whether the PDF contains selectable text or is composed of scanned images.2 For PDFs with selectable text, MarkItDown, likely using libraries like pdfminer.six, can extract the text content. For scanned PDFs, Optical Character Recognition (OCR) is necessary to convert the images of text into actual text.

⚡ Image Files:

• Extracting EXIF Data: MarkItDown can extract metadata from image files in formats like JPEG: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“photo.jpg”) print(result.text_content)

This will typically extract EXIF (Exchangeable Image File Format) data embedded in the image, which can include details about the camera, date, and time the photo was taken, and potentially GPS coordinates. This metadata is then included in the Markdown output, often in a list or table format. Libraries like Pillow (PIL) or exifread are likely used for this purpose.

• Leveraging LLMs (via Ollama) for Image Descriptions: To generate textual descriptions of images using a local Ollama server and a model like LLaVA, you can integrate MarkItDown with the OpenAI client: Python import os from openai import OpenAI from markitdown import MarkItDown

ollama_base_url = os.environ.get(“OLLAMA_BASE_URL”, “http://localhost:11434/v1”) ollama_api_key = os.environ.get(“OLLAMA_API_KEY”, “ollama”) # Dummy key

client = OpenAI( api_key=ollama_api_key, base_url=ollama_base_url, )

md = MarkItDown(llm_client=client, llm_model=“llava”) result = md.convert(“image.jpg”) print(result.text_content)

This code snippet initializes an OpenAI client configured to communicate with the local Ollama server. It then creates a MarkItDown instance, passing the client and the name of the LLaVA model (or another suitable vision-language model available in your Ollama setup) to the llm_client and llm_model parameters, respectively.1 When an image file is converted, MarkItDown will send it to the LLaVA model running on Ollama, and the resulting Markdown will include a description of the image generated by the LLM.

⚡ Audio Files:

• Extracting Metadata: Similar to images, metadata can be extracted from audio files: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“audio.mp3”) print(result.text_content)

This process retrieves metadata such as the title, artist, album, and track information from the audio file and presents it in Markdown format, likely using libraries like mutagen or tinytag.

• Utilizing LLMs (via Ollama) for Speech Transcription: To transcribe audio files using an LLM hosted on your local Ollama server (assuming a suitable model like Whisper or a similar speech-to-text model is available): Python import os from openai import OpenAI from markitdown import MarkItDown

ollama_base_url = os.environ.get(“OLLAMA_BASE_URL”, “http://localhost:11434/v1”) ollama_api_key = os.environ.get(“OLLAMA_API_KEY”, “ollama”) # Dummy key

client = OpenAI( api_key=ollama_api_key, base_url=ollama_base_url, )

md = MarkItDown(llm_client=client, llm_model=“whisper”) # Assuming ‘whisper’ or a similar model is available on Ollama

result = md.convert(“recording.wav”) print(result.text_content)

This code is analogous to the image processing example, but here the llm_model is set to a speech-to-text model. MarkItDown, with the [audio-transcription] dependency installed, would likely process the audio file and send it to the specified LLM on Ollama for transcription. The resulting Markdown would then contain the transcribed text.

⚡ Other Formats:

• XML: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“data.xml”) print(result.text_content)

Conversion of XML files involves parsing the XML structure and extracting relevant content, which is then formatted as Markdown. The specific Markdown output will depend on the XML’s structure and the information deemed important for extraction. Libraries like xml.etree. ElementTree or lxml are likely used for parsing.

• ZIP Files: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“archive.zip”) for name, content in result.zip_contents.items(): print(f”File: {name}\n{content.text_content}\n---”)

MarkItDown can process ZIP archives by iterating through their contents.2 The result object might contain a dictionary-like attribute (e.g., zip_contents) where keys are the names of the files within the archive and values are the converted content of each file as DocumentConverterResult objects. This allows for batch processing of multiple files within a single archive.

• YouTube URLs: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“https://www.youtube.com/watch?v=example”) print(result.text_content)

When provided with a YouTube URL, MarkItDown can attempt to fetch and convert the video’s transcript to Markdown.3 This functionality requires the youtube-transcription optional dependency, which likely uses libraries to interact with YouTube’s services and retrieve the transcript.

• EPubs: Python from markitdown import MarkItDown md = MarkItDown() result = md.convert(“book.epub”) print(result.text_content)

MarkItDown supports the conversion of EPub files, a common format for electronic books, to Markdown.3 This likely involves parsing the EPub file’s structure (which is essentially a ZIP archive containing HTML, CSS, and other resources) and extracting the main textual content, formatting it as Markdown. Libraries like ebooklib might be used for this purpose.

⚡ Integrating MarkItDown with Local Ollama Server

To effectively utilize MarkItDown with a local Ollama server, it is first necessary to have Ollama installed and running on your machine. Ollama allows you to run open-source LLMs locally.8 You can find detailed installation instructions on the official Ollama website. Once installed, you can pull various models, such as llava for image processing and other models like llama2, mistral, or potentially a speech-to-text model, using the ollama pull <model_name> command. After setting up Ollama, you can use the Markdown output from MarkItDown as input for the locally hosted LLMs. The result.text_content attribute of the object returned by MarkItDown’s convert() method contains the Markdown-formatted text, which can be directly used as the content in messages sent to the LLM via the OpenAI client.

⚡ Summarizing a Document Converted to Markdown using Ollama:

Python

import os from openai import OpenAI from markitdown import MarkItDown

ollama_base_url = os.environ.get(“OLLAMA_BASE_URL”, “http://localhost:11434/v1”) ollama_api_key = os.environ.get(“OLLAMA_API_KEY”, “ollama”) # Dummy key for Ollama

client = OpenAI( api_key=ollama_api_key, base_url=ollama_base_url, )

md = MarkItDown() result = md.convert(“large_document.pdf”) markdown_content = result.text_content

chat_completion = client.chat.completions.create( model=“llama2”, # Or any other suitable model available in Ollama (e.g., “mistral”, “orca-mini”)

messages=, ) summary = chat_completion.choices.message.content print(summary)

This example illustrates the complete process of converting a PDF document to Markdown using MarkItDown and then feeding that Markdown content to a local LLM (here, llama2 is used as an example) running on Ollama for summarization. The prompt instructs the LLM to summarize the provided Markdown content.

⚡ Question Answering using Ollama with Markdown Input:

Python

#… (previous setup for Ollama client and MarkItDown)…

md = MarkItDown() result = md.convert(“technical_manual.pdf”) markdown_content = result.text_content

question = “What are the key features of this product as described in the manual?” chat_completion = client.chat.completions.create( model=“mistral”, # Another model example available in Ollama

messages=, ) answer = chat_completion.choices.message.content print(answer)

This demonstrates how the Markdown output can be used for question answering. The Markdown content of a technical manual is provided to the mistral model on Ollama, along with a specific question. The LLM then attempts to answer the question based on the information present in the Markdown content.

⚡ Image Captioning using LLaVA with Ollama and MarkItDown:

The integration for image captioning using LLaVA with Ollama and MarkItDown was already covered in the Image Files section. The key is to initialize MarkItDown with the configured Ollama client and the llm_model set to “llava”.

⚡ Advanced Usage and Customization

The convert() method in MarkItDown might offer additional parameters for customizing the conversion process beyond the style_map used for DOCX. Reviewing the library’s official documentation or source code would provide details on any such parameters that could control aspects like table formatting, heading styles, or the handling of specific document elements. As discussed in the Installation Guide, MarkItDown utilizes optional dependencies to support various file formats. Users should ensure they have installed the dependencies relevant to the file types they need to process. MarkItDown also supports third-party plugins, which can extend its functionality. These plugins are disabled by default.3 You can list installed plugins using the command markitdown —list-plugins and enable them using markitdown —use-plugins <plugin_name1>,<plugin_name2>.

Plugins can be found by searching GitHub for the hashtag #markitdown-plugin. The convert_stream() method offers an alternative way to convert files. As of version 0.1.0, this method requires a binary file-like object as input, such as a file opened in binary mode (‘rb’) or an io. BytesIO object.3 This can be particularly useful for processing large files more memory-efficiently or for handling data that is not directly available as a file path, like content downloaded from a URL:

Python

from markitdown import MarkItDown import requests import io

url = “https://example.com/large\_document.pdf” response = requests.get(url) response.raise_for_status() bytes_io = io. BytesIO(response.content)

md = MarkItDown() result = md.convert_stream(bytes_io) print(result.text_content)

⚡ MarkItDown Command-Line Interface (CLI) in Depth

The MarkItDown CLI provides a set of commands and options for performing conversions directly from the terminal. The —help option will display a comprehensive list of available options. Key options include:

• -o <output_file>: Specifies the name of the file to which the converted Markdown will be written.3

• —use-plugins <plugin_name>: Enables the use of specified plugins for the conversion.3 Multiple plugins can be listed, separated by commas.

• -d: Activates the use of Microsoft Azure Document Intelligence for the conversion process.3 This requires the az-doc-intel optional dependency to be installed.

• -e : Specifies the endpoint URL for your Azure Document Intelligence Resource, which is necessary when using the -d option.3

• —list-plugins: Displays a list of all MarkItDown plugins that are currently installed in your environment.3

Here are some practical examples of using the CLI:

• Convert a Word document named my_document.docx and save the output as my_document.md: Bash markitdown my_document.docx -o my_document.md

• Convert a scanned PDF document using Azure Document Intelligence (assuming you have set up an Azure Document Intelligence Resource and installed the az-doc-intel dependency): Bash markitdown -d scanned_document.pdf -o output.md -e https://your-resource.cognitiveservices.azure.com/

• List all installed MarkItDown plugins: Bash markitdown —list-plugins

• Convert a file named custom_format.xyz using a plugin called special_converter: Bash markitdown —use-plugins special_converter custom_format.xyz -o converted.md

• Convert all .txt files in the current directory to .md files: Bash for file in *.txt; do markitdown “$file” -o ”${file%.txt}.md”; done

⚡ Integrating MarkItDown in Applications

MarkItDown can be seamlessly integrated into larger Python applications or web services. The following example demonstrates how to use MarkItDown within a simple web API built using FastAPI:

Python

import shutil from markitdown import MarkItDown from fastapi import FastAPI, UploadFile from uuid import uuid4

md = MarkItDown() app = FastAPI()

@app.post(“/convert”) async def convert_markdown(file: UploadFile): unique_id = uuid4() temp_dir = f”./temp/{unique_id}” shutil.os.makedirs(temp_dir, exist_ok=True) file_path = f”{temp_dir}/{file.filename}” with open(file_path, “wb”) as f: shutil.copyfileobj(file.file, f) try: result = md.convert(file_path) content = result.text_content finally: shutil.rmtree(temp_dir) return {“result”: content}

To run this FastAPI application, you would typically save the code in a file named main.py and then execute the command uvicorn main:app —reload in your terminal. This starts a local web server. You can then send a POST request to the /convert endpoint with a file attached. For example, using curl:

Bash

curl -X POST -F “file=@your_document.pdf” http://localhost:8000/convert

This will upload the your_document.pdf file to the API, which will then use MarkItDown to convert it to Markdown and return the Markdown content in the JSON response. This demonstrates how MarkItDown can be incorporated into web services to provide on-demand file conversion capabilities.

⚡ Conclusion and Best Practices

MarkItDown offers a robust and versatile solution for converting a wide array of file formats into Markdown, making it an invaluable tool for preparing data for LLMs and text analysis pipelines. Its support for numerous formats, ease of use through both its Python API and CLI, and extensibility via plugins make it highly adaptable to various needs. To optimize your experience with MarkItDown:

• For PDF documents, especially scanned ones, consider performing OCR using a dedicated tool before conversion to ensure accurate text extraction. Be mindful that complex formatting might not be perfectly preserved.

• When working with images and audio, remember that generating descriptions and transcriptions requires integration with an LLM. For local LLM usage, ensure you have Ollama set up correctly with the necessary models.

• Install only the optional dependencies that are relevant to the file types you plan to work with to maintain a clean and efficient environment.

• Explore the possibility of using or developing plugins if you have specific conversion requirements not met by the core library.

• Always test the generated Markdown output with your target LLM and the intended tasks to ensure it is suitable. You might need to adjust prompts or perform some post-processing of the Markdown in certain cases.

• For very large files, utilize the convert_stream() method to minimize memory usage.

• Keep your MarkItDown library updated to take advantage of the latest features, improvements, and bug fixes.

• When using local LLMs via Ollama, ensure that the required models are downloaded and running. By adhering to these best practices, you can effectively leverage MarkItDown to streamline your data preparation process for local LLM-based text analysis and other applications.

⚡ Table 1: Supported File Formats

File Extension	File Type Description	Specific Handling/Notes
.pdf	PDF Document	Requires OCR for scanned documents; formatting might be lost.
.docx	Microsoft Word Document	Supports comment extraction via style_map.
.pptx	Microsoft PowerPoint Presentation	Extracts slide content and notes.
.xlsx	Microsoft Excel Spreadsheet	Multi-tab spreadsheets are handled, with each sheet likely converted to a separate Markdown table.
.xls	Older Microsoft Excel Spreadsheet
.jpg,.png, etc.	Image File	Extracts EXIF metadata; requires LLM integration for description generation.
.mp3,.wav	Audio File	Extracts metadata; requires LLM integration for speech transcription.
.html	HTML Document	Special handling for Wikipedia pages.
.xml	XML Document	Content extraction depends on XML structure.
.csv	CSV File	Converted to Markdown tables.
.json	JSON File	Might be converted to Markdown code blocks, lists, or tables depending on structure.
.zip	ZIP Archive	Iterates over contents, processing supported files within.
YouTube URL	YouTube Video	Fetches and converts video transcript (requires youtube-transcription dependency).
.epub	EPub File	Common format for electronic books.
.txt	Plain Text File	Converted directly to Markdown.
Outlook	Outlook Message	Requires outlook dependency.

⚡ Table 2: Optional Dependencies

Optional Dependency Group	Description
all	Installs all optional dependencies.
pdf	Dependencies for PDF files.
docx	Dependencies for Word files.
pptx	Dependencies for PowerPoint files.
xlsx	Dependencies for Excel files.
xls	Dependencies for older Excel files.
outlook	Dependencies for Outlook messages.
az-doc-intel	Dependencies for Azure Document Intelligence.
audio-transcription	Dependencies for audio transcription of wav and mp3 files.
youtube-transcription	Dependencies for fetching YouTube video transcription.

⚡ Table 3: CLI Options

Command-Line Option	Description
—help	Show help message and exit.
-o <output_file>	Specify the output file name.
—use-plugins <plugin_name>	Enable the specified plugins (comma-separated).
-d	Enable Azure Document Intelligence for conversion.
-e	Specify the Azure Document Intelligence endpoint.
—list-plugins	List all installed MarkItDown plugins.

🔧 Works cited

1. MarkItDown is a new Python Library from Microsoft that aims to …, accessed on April 2, 2025, https://corti.com/markitdown-is-a-python-library-that-aims-to-convert-everything-to-markdown-2/ 2. Deep Dive into Microsoft MarkItDown - DEV Community, accessed on April 2, 2025, https://dev.to/leapcell/deep-dive-into-microsoft-markitdown-4if5 3. microsoft/markitdown: Python tool for converting files and … - GitHub, accessed on April 2, 2025, https://github.com/microsoft/markitdown 4. MarkItDown: Python Tool for Converting Files and Office Documents to Markdown, accessed on April 2, 2025, https://daringfireball.net/linked/2024/12/13/markitdown 5. MarkItDown utility and LLMs are great match - Kalle Marjokorpi, accessed on April 2, 2025, https://www.kallemarjokorpi.fi/blog/markitdown-utility-and-llms-are-great-match/ 6. markitdown · PyPI, accessed on April 2, 2025, https://pypi.org/project/markitdown/ 7. python - Converting Document Docx with Comments to markit using …, accessed on April 2, 2025, https://stackoverflow.com/questions/79329385/converting-document-docx-with-comments-to-markit-using-markitdown 8. Microsoft MarkItDown + Ollama and LLaVA: Markdown Conversion …, accessed on April 2, 2025, https://medium.com/@giacomo__95/markitdown-ollama-and-llava-markdown-conversion-with-microsofts-markitdown-and-ollama-s-llm-2141bba9d183