Integrations

pip install langchain-community

from langchain_community.document_loaders import DoclingLoader

# Load document
loader = DoclingLoader("document.pdf")
documents = loader.load()

# Use in LangChain chain
from langchain.chains import RetrievalQA
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(documents, embeddings)

qa_chain = RetrievalQA.from_chain_type(
    llm=your_llm,
    retriever=vectorstore.as_retriever()
)

response = qa_chain.run("What is this document about?")

from langchain_community.document_loaders import DoclingLoader

loader = DoclingLoader(
    "document.pdf",
    pipeline="vlm",
    vlm_model="granite_docling"
)
documents = loader.load()

pip install llama-index-readers-docling

from llama_index.readers.docling import DoclingReader
from llama_index import VectorStoreIndex

# Load documents
reader = DoclingReader()
documents = reader.load_data("document.pdf")

# Create index
index = VectorStoreIndex.from_documents(documents)

# Query
query_engine = index.as_query_engine()
response = query_engine.query("Summarize this document")
print(response)

from llama_index.readers.docling import DoclingReader

reader = DoclingReader(
    pipeline="vlm",
    vlm_model="granite_docling"
)
documents = reader.load_data("document.pdf")

pip install crewai docling

from crewai import Agent, Task, Crew
from docling.document_converter import DocumentConverter

# Convert document with Docling
converter = DocumentConverter()
result = converter.convert("document.pdf")
document_content = result.document.export_to_markdown()

# Use in Crew AI agent
researcher = Agent(
    role='Research Analyst',
    goal='Analyze documents and extract insights',
    backstory='Expert at document analysis',
    verbose=True
)

task = Task(
    description=f'Analyze this document: {document_content[:1000]}...',
    agent=researcher
)

crew = Crew(
    agents=[researcher],
    tasks=[task]
)

result = crew.kickoff()

pip install haystack-ai docling

from haystack.document_stores import InMemoryDocumentStore
from haystack.nodes import DoclingConverter
from haystack.pipelines import Pipeline

# Convert document
converter = DoclingConverter()
documents = converter.convert("document.pdf")

# Store in document store
document_store = InMemoryDocumentStore()
document_store.write_documents(documents)

# Create pipeline
pipeline = Pipeline()
pipeline.add_node(component=document_store, name="DocumentStore", inputs=["Query"])

# Use in Haystack pipeline
# ... your Haystack pipeline configuration ...

from docling.document_converter import DocumentConverter

def process_document_for_your_framework(file_path):
    """Convert document and return in your framework's format"""
    converter = DocumentConverter()
    result = converter.convert(file_path)
    
    # Export to your preferred format
    markdown = result.document.export_to_markdown()
    
    # Convert to your framework's document format
    # ... your conversion logic ...
    
    return your_framework_documents

# Use in your application
documents = process_document_for_your_framework("document.pdf")

from docling.document_converter import DocumentConverter
from docling.exceptions import DoclingError

try:
    converter = DocumentConverter()
    result = converter.convert("document.pdf")
    documents = result.document.export_to_markdown()
except DoclingError as e:
    # Handle Docling-specific errors
    print(f"Docling error: {e}")
except Exception as e:
    # Handle other errors
    print(f"Error: {e}")

import hashlib
import pickle
import os

def get_cached_document(file_path):
    cache_dir = ".docling_cache"
    os.makedirs(cache_dir, exist_ok=True)
    
    # Create cache key from file hash
    with open(file_path, "rb") as f:
        file_hash = hashlib.md5(f.read()).hexdigest()
    
    cache_path = os.path.join(cache_dir, f"{file_hash}.pkl")
    
    if os.path.exists(cache_path):
        with open(cache_path, "rb") as f:
            return pickle.load(f)
    
    # Convert and cache
    converter = DocumentConverter()
    result = converter.convert(file_path)
    
    with open(cache_path, "wb") as f:
        pickle.dump(result.document, f)
    
    return result.document

from docling.document_converter import DocumentConverter
from concurrent.futures import ThreadPoolExecutor

def process_documents(file_paths):
    converter = DocumentConverter()
    
    def convert_one(path):
        return converter.convert(path).document
    
    with ThreadPoolExecutor(max_workers=4) as executor:
        documents = list(executor.map(convert_one, file_paths))
    
    return documents