Flexible GraphRAG v0.8.0: Optional Integrations: Rust-based CocoIndex Pipeline, Visual Langflow Flows

[u/stevereiner]

GitHub: https://github.com/stevereiner/flexible-graphrag

Flexible GraphRAG v0.8.0 adds two more ingest pipelines — a Rust-based CocoIndex pipeline and a Visual Langflow mode — for three in total. Whichever one you configure, you keep the same configurable data sources and database targets, the same REST and MCP APIs, the same web UI, and the same .env configuration.

Architecture diagram: three ingest pipelines, one configuration

It also shows that the CocoIndex pipeline can run standalone through app.py and the CocoIndex CLI, without the FastAPI REST server.

What Flexible GraphRAG Provides

Flexible GraphRAG is an Apache-2.0 open-source AI context platform for document processing, knowledge-graph construction, hybrid retrieval, GraphRAG/RAG, and AI-assisted query/chat.

It supports Docling, LlamaParse, and LiteParse document processing; ontology/schema-aware knowledge-graph extraction; 13 LLM providers; and hybrid retrieval across full-text, vector, property-graph, and RDF/SPARQL backends.

It supports incremental updating of all target databases, using event change detectors for the 10 auto-sync data sources — either with the original Python-based / PostgreSQL-managed incremental update system (default and Langflow pipelines), or with the Rust-based CocoIndex engine (CocoIndex pipeline).

The main backend is Python, with full support for LlamaIndex and LangChain — and now CocoIndex "native" too. Angular, React, and Vue TypeScript front ends are included, together with an MCP server.

Three Ingest Pipelines — Pick One

The existing Python-based Flexible GraphRAG pipeline remains the default. You configure one of the three:

• Default pipeline: LlamaIndex / LangChain ingest, hybrid search, AI query/chat, and Python/PostgreSQL-managed incremental updates.
• CocoIndex pipeline: Rust-based incremental processing; can mix CocoIndex-native and Flexible GraphRAG components.
• Langflow flows: customizable visual ingest/search/AI-query flows with 12 Flexible GraphRAG Langflow components.

Important: CocoIndex mode and Langflow mode are separate modes; they cannot be enabled together.

CocoIndex Integration

CocoIndex: https://github.com/cocoindex-io/cocoindex

The CocoIndex pipeline works within Flexible GraphRAG and can use the same UI, REST APIs, MCP APIs, data source configuration, and Flexible GraphRAG targets as the default pipeline.

It can mix:

• CocoIndex-native components: source connectors, functions, splitting, and CocoIndex-native graph/vector target connectors.
• Flexible GraphRAG components: data sources, LlamaIndex/LangChain targets, LiteParse/Docling/LlamaParse document processing, splitting/chunking, ontologies, and knowledge-graph auto-building extraction.

For each configured backend category—source, chunker/splitter, property graph, vector database, search backend, and KG extractor—the .env configuration can select llamaindex, langchain, or cocoindex. The actual database selection is configured independently.

Incremental Processing

In CocoIndex mode, Rust based CocoIndex provides the incremental update engine instead of the default Flexible GraphRAG Python/PostgreSQL per-file-state auto update incremental system. PostgreSQL remains available to track the multiple data sources configured through the UI.

For Flexible GraphRAG data sources used by the CocoIndex pipeline, the existing event change detectors continue to be used. These include:

• Alfresco ActiveMQ
• Nuxeo Kafka
• Amazon S3 SQS
• Azure Blob change feed
• Google Cloud Storage Pub/Sub
• Google Drive Changes API polling
• OneDrive/SharePoint Microsoft Graph delta queries
• Box Events API polling
• Local filesystem watchdog

Use the Flexible GraphRAG CocoIndex Pipeline Outside the UI App Too

The CocoIndex pipeline's app.py can also be used outside the UI application, for custom mixed applications that combine CocoIndex-native and Flexible GraphRAG components in your own code.

CocoIndex CLI support is available as well, so the same pipeline can be run standalone — without the FastAPI REST server or any of the web front ends.

Langflow Integration

The Langflow integration enables visual flows for ingest, hybrid search, AI query, and AI chat behind the Flexible GraphRAG UI, REST API, and MCP server.

The supplied flows reproduce the default pipeline behavior but can be visually customized. The integration includes 12 configurable Flexible GraphRAG Langflow components that can also be used in other applications.

The components are themselves Python-based, and use the Flexible GraphRAG Python "framework" — the same code the default pipeline runs. So this is not a separate reimplementation: it makes the default Python-based pipeline (hybrid_system.py) modular and visually customizable.

Langflow plus the components can run in a separate virtual environment, or through the Flexible GraphRAG backend Docker image together with the Langflow + Flexible components image.

When ENABLE_LANGFLOW_FLOWS=true, the app UI, MCP server, and REST API use the visual flows. All 14 data sources and the selected document processor—Docling, LlamaParse, or LiteParse—are supported. If ENABLE_INCREMENTAL_UPDATES=true is also enabled, changes from the auto-sync sources run through the Langflow ingest flow.

Sources and Targets

• 14 data sources, with 10 auto-sync sources: Alfresco, Nuxeo, Amazon S3, Google Cloud Storage (GCS), Azure Blob Storage, SharePoint, OneDrive, Google Drive, Box, and local filesystem. Other sources are CMIS, web pages, YouTube, and Wikipedia.
• 15 property-graph databases: Neo4j, ArcadeDB, FalkorDB, LadybugDB, Amazon Neptune, Neptune Analytics, Memgraph, NebulaGraph, Google Cloud Spanner, ArangoDB, Apache AGE, HugeGraph, SurrealDB, TigerGraph, and Azure Cosmos DB Gremlin.
• 4 RDF/triple stores: Apache Jena Fuseki, Graphwise/Ontotext GraphDB, Oxigraph, and Amazon Neptune RDF.
• 10 vector databases: Qdrant, Neo4j, Elasticsearch, OpenSearch, Chroma, Milvus, Weaviate, Pinecone, PostgreSQL/pgvector, and LanceDB.
• 3 search engines: OpenSearch, Elasticsearch, and BM25.
• 13 LLM providers: OpenAI, Ollama, Azure OpenAI, Google Gemini, Anthropic Claude, Google Vertex AI, Amazon Bedrock, Groq, Fireworks AI, OpenAI-compatible endpoints (LM Studio, vLLM, LocalAI), OpenRouter (200+ models), LiteLLM Proxy (100+ providers), and vLLM.

Databases and dashboards can be enabled from the Docker Compose configuration. Optional Docker images are available for the backend, Langflow plus Flexible components, and React/Angular/Vue front ends:

https://hub.docker.com/u/integratedsemantics

Also Since v0.6.3

v0.7.2

• Added Nuxeo as a document/content data source alongside Alfresco.
• Added OAuth 2.0 support for Nuxeo, Alfresco, and MCP.

v0.7.1

• Added LiteParse document processing alongside Docling and LlamaParse.
• Delivered Langflow integration fixes and an optional Langflow Docker image bundling the 12 Flexible components.
• Added Microsoft Graph delta-query support for more efficient SharePoint and OneDrive incremental updates.

Earlier Announcement

Previous v0.6.3 Reddit post:

https://www.reddit.com/r/Rag/comments/1ucummg/flexible_graphrag_v063_available/

Feedback, issues, ideas, and PR contributions are welcome.