Docling Studio 0.4.0 — From Document Viewer to RAG Pipeline Debugger

When I started building Docling Studio, the goal was simple: give developers a visual way to inspect what Docling extracts from documents. Bounding boxes, chunks, metadata — the stuff you need to see to trust your pipeline.

But anyone who's built a RAG system knows the real problem isn't extraction. It's everything that happens after. Your chunks look fine in JSON. Then you embed them, index them, run a query — and the answers are garbage. Good luck figuring out which chunk went wrong when you're staring at vector IDs in OpenSearch.

Version 0.4.0 closes that gap. Docling Studio now owns the full loop: Docling → chunking → embedding → OpenSearch. You can ingest, search, inspect, edit chunks, and re-embed — all from the same interface where you already see your document's structure.

This is the release where Docling Studio stops being a viewer and becomes a RAG pipeline debugger.

The core idea: own the ingestion pipeline

The architectural bet behind this release is straightforward. Instead of depending on an external orchestrator to store the right metadata, Docling Studio runs its own ingestion pipeline. Docling parses the document, Studio chunks it, an embedding microservice vectorizes the chunks, and OpenSearch indexes everything — including bounding boxes and document coordinates.

Why does this matter? Because when you can trace a bad search result back to its exact chunk, see that chunk highlighted on the original PDF page, edit the text, and re-embed it — you've just turned a 2-hour debugging session into a 30-second fix.

The pipeline is orchestrated end-to-end with idempotent re-ingestion. Re-ingest the same document and it cleanly replaces the previous version. No orphaned vectors, no duplicate chunks.

A fourth Studio mode: Ingest

Docling Studio's workflow was already organized in three modes — Configure, Verify, Prepare. Version 0.4.0 adds a fourth: Ingest.

Once your document analysis is complete, one click sends the chunks through embedding and into OpenSearch. A visual stepper tracks progress (Embedding → Indexing → Done) with animated feedback. No terminal needed, no curl commands.

The Ingest mode also includes full-text search across indexed chunks. You get a dedicated search sidebar where you can query your indexed documents and see relevance scores — raw BM25 scores, not the misleading percentages we had before (that's fixed too).

Chunk editing before you embed

This is the feature I'm most excited about. You can now edit chunk text inline — double-click a chunk, modify the text, save. You can also soft-delete chunks you don't want indexed. Deleted chunks stay in the data (nothing is lost) but disappear from the UI and won't be embedded.

This is what "debugging" actually means for RAG. You see a chunk that merged a table header with body text? Fix it. A chunk captured a page footer? Delete it. Then re-ingest. The feedback loop is measured in seconds, not deployment cycles.

My Documents & monitoring

A new My Documents screen gives you an overview of everything in the system. Filter by ingestion status (all / indexed / not indexed), sort by name or date, and see at a glance which documents are ready and which aren't.

An OpenSearch connection indicator in the sidebar footer (green/red dot, polling every 30 seconds) tells you whether your backend is healthy without switching to another tool.

Feature flags: the pipeline is opt-in

Not everyone needs the full ingestion stack. If you just want the visual inspection features, nothing changes — Docling Studio works exactly as before.

The ingestion pipeline activates when you set OPENSEARCH_URL and EMBEDDING_URL. The frontend automatically hides all ingestion UI when these aren't configured. No dead buttons, no confusing screens.

For those who do want the full stack, a dedicated docker-compose.ingestion.yml override spins up OpenSearch, the embedding service, and everything else with a single command.

Under the hood

A few things I want to highlight for the architecturally curious:

Hexagonal architecture pays off. The VectorStore port defines the contract (ensure_index, index_chunks, search_similar, get_chunks, delete_document). The OpenSearch adapter implements it. When someone asks for Qdrant or Weaviate support, it's a new adapter — not a refactor.

The embedding service is standalone. It's a separate container running sentence-transformers behind a REST API with batch processing. The EmbeddingService port and EmbeddingClient HTTP adapter keep it decoupled. Swap the model, swap the service — Studio doesn't care.

OpenSearch mapping uses FAISS/HNSW kNN with configurable embedding dimensions. The IndexedChunk domain model carries everything: text, vector, bounding box coordinates, document reference, chunk metadata.

Tests: 380 backend, 161 frontend, plus E2E Karate tests covering the full ingestion workflow from PDF upload to chunks landing in OpenSearch.

Try it

# Quick start — visual inspection only
docker pull ghcr.io/scub-france/docling-studio:0.4.0-remote
docker compose up
# Full stack with ingestion pipeline (opensearch + embeddings)
docker compose -f docker-compose.yml -f docker-compose.ingestion.yml up

# Quick start — visual inspection only
docker pull ghcr.io/scub-france/docling-studio:0.4.0-remote
docker compose up
# Full stack with ingestion pipeline (opensearch + embeddings)
docker compose -f docker-compose.yml -f docker-compose.ingestion.yml up

Two image variants: 0.4.0-remote (lightweight, delegates to Docling Serve) and 0.4.0-local (full Docling in-process).

The repo is at github.com/scub-france/Docling-Studio. Stars are nice, issues and forks are better.

What's next

This release lays the foundation. The ingestion pipeline and chunk editing loop are the building blocks for everything coming next — side-by-side model comparison, smarter chunking strategies, and deeper integration with the Docling ecosystem.

If you're building RAG pipelines and spending too much time wondering why your retrieval is off, give Docling Studio a shot. The whole point is to make the invisible visible.

I am CTO at SCUB, a French IT services company, and AI Ambassador for the French Ministry of Economy ("Osez l'IA"). I design production AI systems, contribute to open-source tooling, and write about the intersection of architecture and AI-assisted development.

My latest project is Docling Studio, a visual inspection layer for document parsing pipelines built on IBM's Docling ecosystem.

Thank you for reading! If you found this article useful, please feel free to 👏 and help others find it. I welcome your thoughts in the comments section below.