RAGLight

What does this agent do, and when should you use it?

RAGLight is a Python library for building Retrieval-Augmented Generation applications, unifying document retrieval and LLM inference through both a Builder API and high-level RAGPipeline / AgenticRAGPipeline classes. It is LLM-agnostic, supporting Ollama, LMStudio, vLLM, OpenAI, Mistral, Google Gemini, and AWS Bedrock, with ChromaDB and Qdrant as vector stores that can run locally on disk or remotely over HTTP. Beyond the standard RAG pipeline, it ships an Agentic RAG pipeline that can reach external tools such as code execution and databases via MCP servers. Deployment options include an interactive CLI wizard (raglight chat / raglight agentic-chat), a FastAPI REST server (raglight serve, optionally with a Streamlit chat UI), and Docker / Docker Compose. Retrieval features cover semantic, BM25, and RRF hybrid search, query reformulation, multi-turn conversation history, token-level streaming, and end-to-end tracing with Langfuse.

RAGLight ingests local folders or GitHub repositories (FolderSource / GitHubSource), parses PDF, TXT, DOCX, and code files using built-in extension-based processors (PDFProcessor, CodeProcessor, TextProcessor — overridable, including a VLM-based PDF processor), embeds them, and writes them into a ChromaDB or Qdrant collection in local or remote mode. At query time it runs reformulate → retrieve → rerank → generate: it rewrites follow-up questions into standalone queries, retrieves via semantic, BM25, or hybrid (RRF-fused) search, then generates an answer with the selected LLM. APIs include the RAGPipeline / AgenticRAGPipeline high-level classes and the chained Builder (with_embeddings / with_vector_store / with_llm); AgenticRAGConfig accepts an mcp_config parameter for MCP server integration. The CLI offers raglight chat and raglight agentic-chat wizards; raglight serve starts a FastAPI server exposing /health, /generate, /ingest, /ingest/upload, /collections, and /config endpoints, all configured via RAGLIGHT_* environment variables, with --ui launching a Streamlit chat interface alongside. All providers support generate_streaming() and a max_history-capped conversation history, and every generate() call can be traced in Langfuse as a trace with per-node spans.

1. A developer who wants a private, local document Q&A system (e.g. Ollama + Qdrant) where data never leaves the machine
2. A backend team exposing enterprise knowledge bases as a REST API so other apps can query documents via the /generate endpoint
3. An engineer with existing OpenAI, Mistral, or Gemini API keys who wants to swap LLM providers with minimal component changes
4. A multi-turn chat application where users ask follow-ups like 'and for Python?', needing query reformulation and conversation history
5. A retrieval-system maintainer whose pure vector search recall is insufficient and wants BM25 + semantic RRF hybrid fusion
6. An Agentic RAG experimenter who wants to attach external tools such as code execution or database access via MCP servers

What are this agent's strengths and limitations?

How do you install or deploy this agent?

Base install: pip install raglight

Install extras only for what you need:

pip install "raglight[qdrant]"           # Qdrant (pure Python, Windows-friendly)
pip install "raglight[chroma]"           # ChromaDB (requires a C++ compiler on Windows)
pip install "raglight[chroma,qdrant]"    # both
pip install "raglight[qdrant,langfuse]"  # Qdrant + observability

For local inference, run Ollama and pull a model first. For cloud providers, set the relevant API key environment variable (MISTRAL_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY) or configure AWS credentials (env vars, ~/.aws/credentials, or IAM role) for Bedrock. If using LMStudio, load the target model in LMStudio beforehand.

How do you use this agent?

Fastest start — CLI wizard (requires a running Ollama):

raglight chat        # interactive setup: data source, ignore folders, vector DB, embeddings, LLM
raglight agentic-chat

Deploy the REST API:

raglight serve --port 8000 --ui      # FastAPI + Swagger(/docs) + Streamlit UI on 8501
RAGLIGHT_LLM_MODEL=mistral-small-latest RAGLIGHT_LLM_PROVIDER=Mistral raglight serve

Python high-level API:

from raglight.rag.simple_rag_api import RAGPipeline
from raglight.config.settings import Settings
from raglight.config.rag_config import RAGConfig
from raglight.config.vector_store_config import VectorStoreConfig
from raglight.models.data_source_model import FolderSource, GitHubSource

vector_store_config = VectorStoreConfig(

embedding_model=Settings.DEFAULT_EMBEDDINGS_MODEL,
provider=Settings.HUGGINGFACE,
database=Settings.CHROMA,
persist_directory='./defaultDb',

collection_name=Settings.DEFAULT_COLLECTION_NAME)

config = RAGConfig(llm=Settings.DEFAULT_LLM, provider=Settings.OLLAMA, k=5,

knowledge_base=[FolderSource(path='./docs'), GitHubSource(url='https://github.com/Bessouat40/RAGLight')])
pipeline = RAGPipeline(config, vector_store_config)
pipeline.build()
print(pipeline.generate('your question'))

Alternatively use the chained Builder: Builder().with_embeddings(...).with_vector_store(...).with_llm(...).build_rag(k=5). For Docker, see examples/Dockerfile.example and run with --add-host=host.docker.internal:host-gateway to reach a host Ollama instance.

How does this agent compare with similar options?

FAQ