Integrations
DocsGPT and Zilliz Cloud Integration

DocsGPT and Zilliz Cloud Integration

Integrate Zilliz Cloud with DocsGPT to build a documentation Q&A system that retrieves accurate, GPT-powered answers from your project docs. Use Milvus as the vector database backend to store and search document embeddings at scale, with minimal configuration and no vector infrastructure to manage.

Use this integration for Free

What is DocsGPT?
DocsGPT is an open-source solution that lets developers ask questions about project documentation in natural language and get accurate, GPT-powered answers. Instead of manually searching through docs, users query in plain English and get direct responses grounded in the actual source material. DocsGPT is built to drop into existing projects with minimal setup — it handles document ingestion, embedding, retrieval, and answer generation in a single Dockerized application.

By integrating Zilliz Cloud (fully managed Milvus) with DocsGPT, you can store and retrieve document embeddings at scale, keeping search fast and accurate as your documentation grows without managing any vector database infrastructure yourself.
Benefits of the DocsGPT + Zilliz Cloud Integration
- Answers grounded in your actual documentation. DocsGPT retrieves the most relevant document chunks from Zilliz Cloud before generating a response, keeping answers tied to your content rather than model priors.
- Scale retrieval without operational overhead. Zilliz Cloud handles indexing, replication, and serving at scale. You connect with two environment variables and skip running your own vector database cluster.
- Minimal configuration to switch vector stores. Pointing DocsGPT at Milvus requires only three environment variable changes in docker-compose.yaml — no application code to modify.
- Supports both managed and self-hosted deployments. Use Zilliz Cloud for a fully managed setup, or point DocsGPT at a self-hosted Milvus server if your environment requires it.
- Works naturally with LangChain-based retrieval. DocsGPT uses langchain-milvus under the hood, the same connector used in LangChain + Zilliz Cloud integrations, so the retrieval pipeline is battle-tested.
How the Integration Works
DocsGPT ingests your project documentation, splits it into chunks, and converts each chunk into a vector embedding using GPT models. When a user asks a question, DocsGPT embeds the query and retrieves the most relevant chunks from the vector store before generating a natural-language answer. The quality of retrieval determines the quality of the answer — the vector database is what makes this possible at any meaningful scale.

Zilliz Cloud, the fully managed version of Milvus, provides the vector database layer for storing, indexing, and retrieving embeddings at scale. DocsGPT connects to it through a URI and API token passed as environment variables, so the same Docker Compose setup works for local development and production. You can learn more about how Milvus handles vector search in the official documentation.

Together, DocsGPT and Zilliz Cloud make it straightforward to build a documentation Q&A system on top of your existing content. This combination helps developers build AI applications that can answer questions accurately against large documentation sets, scale retrieval without managing vector infrastructure, and keep responses grounded in source material rather than generating unsupported answers.
Step-by-Step Guide
1. Clone the repository

Start by cloning the DocsGPT repository to your local machine. The project ships with a Docker Compose setup that handles all service orchestration, so Docker is the only prerequisite beyond Git. Once cloned, navigate into the project directory before running any further commands. (Milvus)
```
git clone https://github.com/arc53/DocsGPT.git
cd DocsGPT
```
2. Add the Milvus dependency

DocsGPT's application layer uses langchain-milvus to communicate with Milvus. Appending it to the requirements.txt under the application folder ensures it gets installed when the Docker image builds — without this step, the backend will fail to connect to the vector store at startup. (Milvus)
```
echo "\nlangchain-milvus==0.1.6" >> ./application/requirements.txt
```
3. Configure environment variables

DocsGPT reads its vector store configuration from environment variables at startup. Both the backend and worker services need the same three variables — the worker handles background embedding jobs independently, so it needs its own connection details. Open docker-compose.yaml and add the following to both service definitions. (Milvus)
```
  backend:
    build: ./application
    environment:
      - VECTOR_STORE=milvus
      - MILVUS_URI=...
      - MILVUS_TOKEN=...
```
```
  worker:
    build: ./application
    command: celery -A application.app.celery worker -l INFO -B
    environment:
      - VECTOR_STORE=milvus
      - MILVUS_URI=...
      - MILVUS_TOKEN=...
```
For MILVUS_URI and MILVUS_TOKEN, you have two options:
- Zilliz Cloud (recommended): Sign up for a free account at cloud.zilliz.com. After creating a cluster, your MILVUS_URI (Public Endpoint) and MILVUS_TOKEN (API key) are available on the cluster detail page.
- Self-hosted Milvus: Follow the official Milvus installation guide to run a Milvus server. Your MILVUS_URI will be in the format http://<your_server_ip>:19530 and MILVUS_TOKEN in the format <your_username>:<your_password>.
4. Start the services

With configuration in place, run the setup script to build images and start all services. The first run will take a few minutes while Docker pulls and builds. Once running, navigate to the local UI to upload documentation and start asking questions. (Milvus)
```
./setup.sh
```
Open http://localhost:5173/ in your browser. You can upload your project documentation and query it directly through the UI.

To stop all running services:
```
docker compose down
```
Learn More