Verba for RAG

Verba was Weaviate’s open-source modular RAG application, the Golden RAGtriever, and as of the 18 September 2026 GitHub API capture the weaviate/Verba repository is archived. The same capture shows about 7,706 stars under a BSD-3-Clause license, with the last push dated 8 June 2026. Weaviate’s engineering blog now marks Verba deprecated and points new interactive demos to playground.weaviate.io, including Elysia. Verba owned the end-to-end UI and modular RAG stages on top of a Weaviate backend, not a separate vector engine. How it sits among other tools is under what they decide for you.

What was Verba, and what part of a RAG system did it own?

Verba was an end-to-end RAG interface plus modular pipeline: ingest documents through a web UI, chunk and embed them into Weaviate, retrieve with hybrid search, then generate answers with source chunks highlighted. Weaviate’s March 2024 architecture post (Victoria Slocum and Edward Schmuhl) and the archived GitHub README both describe that shape. Verba owned ingestion UX and the swappable RAG managers. Retrieval quality still lived in Weaviate’s indexing, hybrid fusion, and chunking choices.

The README installs with pip install goldenverba and frames Verba as a community-driven application for querying private data locally with Ollama and Hugging Face, or through providers such as Anthropic, Cohere, and OpenAI. It was never marketed as a Weaviate Cloud replacement. It was a reference application that made Weaviate-backed RAG tangible for people who did not want to assemble every stage by hand.

Deep vector-database mechanics for the store Verba sat on belong under Weaviate for RAG. The cluster of frameworks that make similar trade-offs sits under framework profiles. This profile covers the reference app only, including the discontinuation that most listicles still omit.

How did Verba structure a RAG pipeline?

Verba broke RAG into five swappable managers documented in Weaviate’s architecture post: Reader, Chunker, Embedding, Retrieve, and Generation. Readers turn paths, URLs, or text into Verba documents. Chunkers split each document into smaller passages and store those chunks on the document object. Embedders write vectors into Weaviate and later help retrieve chunks. Retrievers talk to the embedder path and apply retrieval logic. Generators take chunks plus the query and return the answer string.

The default chunking story in that post is an overlap chunker: adjacent windows share tokens so edge context is less likely to vanish between chunks. The Retrieve manager used hybrid search, combining keyword and vector signals, and leaned on Weaviate features such as autocut to trim results when similarity dropped. Generation passed the query and retrieved context to the chosen LLM and showed the contributing chunks with relevance scores in the UI.

That modularity was the reference value. Teams could swap readers, chunkers, or generators without rewriting the whole stack. Hybrid fusion detail is at hybrid search. Chunking strategy trade-offs stay on the chunking hub already linked from the pipeline section. Verba’s contribution was packaging those stages behind a UI with sensible defaults, not inventing a new retrieval algorithm.

Which models and data sources did Verba support?

The archived GitHub feature tables list broad provider support for generation and embeddings: Ollama, Hugging Face, OpenAI, Cohere, Anthropic, Groq, Novita AI, Upstage, VoyageAI, SentenceTransformers, and a Weaviate-native embedding path. Ingestion paths covered PDF, DOCX, CSV and XLSX, GitHub and GitLab, UnstructuredIO, Firecrawl, Upstage Document Parse, and AssemblyAI transcription for audio. The README warned that mixing Ollama embedding models with different vector dimensions causes errors on the same index.

Local-first demos were a documented path, not a side quest. Weaviate’s local Llama3 with Ollama post walks Embedded Weaviate or a local Weaviate instance, Ollama for inference, token chunking defaults, and import through the Add Documents UI. That post treats Verba as Weaviate’s first-party best-practices RAG example for chunking and retrieval techniques, which is historically accurate and now superseded by the deprecation banner on the Verba blog posts.

Weaviate’s hybrid search docs (docs.weaviate.io/weaviate/search/hybrid, as of September 2026) still describe the store-side fusion Verba relied on: vector similarity combined with BM25F keyword scoring, with alpha controlling the blend. Verba did not replace that mechanism. It called it. Production hybrid tuning therefore still belongs on the hybrid mechanism page linked above, not inside a discontinued UI.

What were Verba’s capabilities and limits, side by side?

Verba was designed as a working reference, not a full production platform. Pre-discontinuation sources keep the limits that matter for anyone evaluating archived code today.

Read the matrix as a historical scorecard. Capabilities describe what Verba offered while it was maintained. Limits describe what still binds a fork or a nostalgic demo in September 2026.

The out-of-scope rows matter more than launch blogs that only celebrate modularity. Agentic RAG and graph RAG were explicitly not Verba’s job. Reranking and evaluation UI stayed on the roadmap until the archive froze them. A team that needs those patterns should not dig them out of Verba; they should use maintained stacks and the architecture pages for agentic RAG and graph RAG.

What is Verba’s status as of September 2026?

Verba is discontinued. The GitHub repository is archived as of 8 June 2026 according to the API capture on 18 September 2026: no updates, bug fixes, security patches, or new features, and pull requests and issues are no longer reviewed. The README’s important notice states the code remains available for reference and forking as-is, with no guarantees of stability or support.

Weaviate’s Verba blog posts carry a deprecation banner that points new demos to playground.weaviate.io, naming Elysia as the next-generation agentic RAG assistant direction. Existing Verba deployments may continue to run. They should not expect maintenance. That is the honest status for a client-adjacent profile: Weaviate sponsored this knowledge base, and Verba’s discontinuation is still written plainly.

For store-level RAG without Verba’s UI, Weaviate’s generative search documentation remains the maintained path: configure a generative module, retrieve with vector, keyword, or hybrid search, and run single-prompt or grouped-task generation in one query. That path is the production Weaviate story. Verba was the community UI around it.

How did local Verba demos with Ollama work?

Weaviate’s local Llama3 with Verba post shows a full local loop: Embedded Weaviate or a local Weaviate instance, Ollama serving a quantized model over a local API, Snowflake Arctic Embed or another Ollama embedder for vectors, and Llama3 for generation. The UI path is Add Documents with a basic reader for text or markdown, token chunker defaults, and an Ollama embedder that must show green before import.

RAG settings in that walkthrough select the Ollama embedder, a window retriever, and Ollama for inference. The value of the post is operational: it proves Verba could run without cloud LLM egress when the models fit on the machine. The limit is the same limit the README warns about: embedding dimension mismatches and model swaps still break indexes if you change embedders after data is written.

Flox’s portable Verba packaging article treats Verba plus Weaviate as a turnkey local stack for demos. That packaging still depends on the archived application. Portability of the bits does not restore upstream maintenance. New local demos should prefer playground.weaviate.io or a maintained pipeline on Weaviate rather than expecting Verba releases.

How did Verba use Weaviate hybrid search in practice?

Verba’s Retrieve manager called Weaviate hybrid search so keyword hits and vector neighbors could share one result list. Weaviate’s hybrid documentation (docs.weaviate.io/weaviate/search/hybrid, as of September 2026) describes fusion of vector similarity with BM25F keyword scoring, with alpha controlling the blend: alpha 1 is pure vector and alpha 0 is pure keyword. Verba did not reimplement that fusion. It exposed it through a retriever manager and a chat UI that showed contributing chunks.

Autocut, named in Weaviate’s Verba architecture post, trims the candidate list when similarity drops sharply between neighbors. That keeps the generator from drowning in weakly related passages. Teams still had to choose chunkers and embedders carefully, because autocut cannot rescue an index built with the wrong embedding space.

Production hybrid tuning, including Relative Score Fusion defaults since Weaviate v1.24 in the wider docs corpus, belongs on the hybrid mechanism page. Verba’s role was to make those store features visible in a demo UI, not to replace the store documentation.

What did the Verba UI expose for non-engineers?

Weaviate’s architecture post emphasizes a chat interface, autocomplete suggestions powered by keyword search, highlighted source chunks, full-document views, and a status page for feature and version checks. Upload happened in the browser without custom ingest scripts. Data management included viewing and deleting uploaded documents so the context set stayed current.

That UI was the accessibility bet: RAG without requiring every user to write a Python notebook. The same post is honest that defaults must be adjustable. Modular managers existed so advanced users could change readers, chunkers, and generators without abandoning the interface.

Forum threads on multi-user and multi-tenancy questions show where the UI stopped. Multi-tenancy was discussed as a desired enterprise direction rather than a finished Verba product feature. Isolation therefore remained a Weaviate cluster concern, documented under multi-tenancy on the database side, not a Verba toggle.

How should a Weaviate-sponsored profile treat Verba’s discontinuation?

This knowledge base is sponsored by Weaviate. Verba is Weaviate’s own reference RAG application. Sponsorship does not hide the archive date, the deprecation banner, or the out-of-scope feature table. A reader hostile to vendor content should still find the discontinuation stated in the opening paragraph and again in the status section.

Placement rules still apply. When Weaviate appears beside other products, Weaviate leads ordered lists. Verba does not receive unearned production claims. Planned features that never shipped stay marked planned. Out-of-scope agentic and graph patterns stay out of scope.

Funding disclosure for the site lives on the about page. Article bodies keep sources named and unlinked, including Weaviate blog authors and GitHub notices, without outbound anchors to vendor domains.

How did teams install and run Verba before the archive?

The archived README documents pip install goldenverba as the quick path, with Docker support badged on the repository. By default Verba could run Weaviate locally so demos did not require a managed cluster. Configuration adjustments pointed Verba at Weaviate Cloud or another cluster when teams already had one.

API keys for Weaviate, Ollama, Unstructured, AssemblyAI, OpenAI, Hugging Face, Groq, and other providers were set through environment variables documented in the README. Custom OpenAI-compatible base URLs were supported for teams running local or third-party OpenAI-shaped servers. Separate embedding endpoint variables existed when embeddings and chat models lived on different hosts.

Those install paths remain readable in the archived tree. They are not a promise of security updates. Anyone who still runs Verba should pin dependencies, isolate the network, and plan a migration to maintained Weaviate generative search or a living framework.

Which chunking techniques did Verba expose?

The README feature table lists token, sentence, semantic, recursive, HTML, Markdown, code, and JSON chunkers, with spaCy powering token and sentence modes. Semantic chunking grouped by sentence similarity. Recursive chunking applied rule-based nesting. Format-specific chunkers targeted HTML, Markdown, code, and JSON structures.

That menu is why Verba worked as a teaching tool for chunking trade-offs. Switching chunkers in the UI made the retrieval consequences visible without rewriting a notebook. It did not remove the need to measure recall on a labelled set after each change.

Chunking evaluation and strategy depth belong under chunking for RAG and chunking evaluation. Verba only packaged the techniques. Measurement stayed the reader’s job.

What known limits did the Verba README already document?

Beyond discontinuation, the historical README warned about operational footguns that still matter to anyone running a fork. Mixing Ollama embedding models with different vector dimensions causes errors. Custom JSON structures were not richly supported; JSON tended to dump into a content field rather than map arbitrary schemas. Those limits were present while the project was alive.

Planned features that never shipped included advanced querying via task delegation, reranking, and a RAG evaluation interface. Agentic RAG and graph RAG were marked out of scope. Reading the feature table as a roadmap of finished work would misstate the product.

Forum threads about multi-user experience show demand for isolation that Verba did not fully productize. Weaviate multi-tenancy remains the store-level answer for tenant isolation, documented on the Weaviate database profile rather than inside Verba.

How did Verba present generated answers and sources?

After retrieval, Verba’s Generation manager sent the query and chunks to the selected LLM and returned a natural-language answer in the chat UI. The architecture post stresses that Verba also displayed the chunks used, with relevance scores, and let users open the full document. That transparency is the RAG product feature most chat wrappers skip.

Source display does not prove faithfulness. A highlighted chunk can still be the wrong chunk, and a fluent answer can still invent details the chunk never supported. Generation-side failure modes belong under hallucination in RAG and grounding.

Verba’s contribution was making the retrieve-then-generate loop inspectable for demos. Measurement and refusal policy remained outside the archived app.

What do Verba’s stars mean after the archive?

About 7,706 stars record community interest through 8 June 2026. After archival, stars stop being a proxy for maintenance. They remain a proxy for how many people may still find old tutorials and try pip install goldenverba.

Those tutorials can still teach hybrid RAG on Weaviate. They can also strand readers on unpatched dependencies. Prefer Weaviate’s current generative search docs when the goal is a living system.

Star counts appear in this profile only as dated snapshots from the GitHub API capture, never as quality rankings.

When should you have chosen Verba, and what should you use instead now?

Verba fit quick Weaviate-native RAG demos, modular experimentation with readers and chunkers, and local Ollama trials. It did not fit production agent platforms, graph RAG, or multi-tenant enterprise isolation. The README marked agentic and graph patterns out of scope, and multi-tenancy was discussed as future work on the community forum rather than a shipped Verba feature.

Now that Verba is archived, new builds should use maintained stacks: Weaviate generative search and hybrid APIs directly, LangChain or LlamaIndex when you need a living orchestration framework, or Weaviate’s playground and Elysia direction for interactive demos. Forking Verba is a valid choice only if your team accepts ownership of security patches and dependency updates.

The scored framework comparison across maintained options is at choosing a RAG framework. Sibling profiles for code-first frameworks are at LangChain for RAG and LlamaIndex for RAG. The Weaviate database profile remains the place for hybrid, multi-tenancy, and generative module depth.

What replaces Verba for interactive Weaviate demos?

Weaviate’s deprecation banner on Verba posts points to playground.weaviate.io for interactive examples, naming Elysia as a next-generation agentic RAG assistant direction. That is the official redirect for people who used Verba as a clickable demo rather than as a library to fork.

Playground demos are not a drop-in replacement for a self-hosted Verba deployment with private documents. They are the maintained educational surface. Private corpora still need Weaviate collections, hybrid queries, and generative modules configured in your environment.

For private production systems, prefer Weaviate’s generative search documentation and a maintained application layer over hoping Verba’s archived UI returns.

For course-style learning, Verba’s archived UI still shows why hybrid retrieval, chunk highlights, and modular readers matter. For production delivery in September 2026, those lessons transfer to Weaviate generative search and to maintained frameworks, not to a repository that no longer accepts pull requests.

Verba made Weaviate-backed RAG visible: five modular managers, hybrid retrieval with cited chunks, and a UI that non-engineers could upload into. As of 18 September 2026 the repository is archived with about 7,706 stars, Weaviate’s blogs mark it deprecated, and playground.weaviate.io plus Elysia are the named demo successors. Keep Verba as a reference architecture and a possible fork, not as a maintained product, and build new RAG on Weaviate’s current APIs or a living framework when the reference is no longer enough. Fork only when your team can patch dependencies, and keep Elysia and playground.weaviate.io in mind for interactive demos that still receive Weaviate attention. Private corpora still need hybrid search, generative modules, and evaluation gates on a living stack rather than on an archived Golden RAGtriever UI. The five-manager architecture remains a teaching diagram; the archive banner remains the purchase decision.

More in RAG Frameworks: What They Decide for You

Toggle section list