Vectara Release Notes
Here's where we keep you up to date with all the latest features and product documentation updates to help you get even more out of the Vectara platform. Every release is listed below, newest first.
For changes to the documentation itself — new and updated guides, context-engineering material, and API reference updates — see the Documentation Changelog.
July 2026
Get Document Tool for Agents
Agents can retrieve a stored document with the new get_document tool.
The tool returns the document's text parts inline and exposes its images
and tables as artifacts that load on demand.
Why it matters: Agents can read a specific document's content directly, pulling in heavier image and table data only when a step actually needs it.
More information:
Narrow Filter Attribute Values with `fuzzy_match`
When listing the distinct values of a corpus filter attribute, you can
now pass a fuzzy_match term to narrow the results. A text value is
returned only if it contains the term, ignoring letter case and
surrounding non-alphanumeric characters — for example, 10k matches
10-K, 10K, and FY24 10-K. Numeric and boolean attribute values are
not affected.
Why it matters: It becomes practical to find matching filter values in corpora that have large attribute value sets, without scanning the full list.
Confluence Cloud Tools for Agents
Agents can now read from Confluence Cloud through two built-in tools:
confluence_fetch retrieves page content, and
confluence_get_attachment retrieves a page's attachments.
Why it matters: Agents can pull knowledge-base content and attached files from Confluence Cloud directly into a session.
More information:
Slack Agent Tools with Bot-Token Credentials
Slack agent tools can now authenticate with a bot token stored as the
slack_bot_token agent secret, as an alternative to attaching a Slack
connector. Store the token with
PUT /v2/agents/{agent_key}/secrets and the Slack tools use it directly.
Why it matters: Teams that already manage a Slack bot token can wire it straight into an agent's secrets without configuring a separate connector.
More information:
Set Up the Zoom Contact Center Connector in the Console
You can now create and configure a Zoom Contact Center connector directly
in the Console. Choose Zoom Contact Center when adding a connector,
then optionally set a Callback URL — provide one for asynchronous
delivery, or leave it blank for synchronous responses — and a Typing
indicator duration in seconds. After the connector is created, a
Finish setup page shows the Webhook URL to register with Zoom and
the Connector token, which is sent in the x-zoom-connector-token
header. The token is generated per connector and is preserved across
updates.
Why it matters: You can stand up a Zoom Contact Center connector and retrieve the values Zoom needs without leaving the Console.
Source Record Metadata for Pipeline Sources
Web, S3, and SharePoint pipeline sources now carry
source_record_metadata, including access-control metadata
(AclMetadata) defined in the API specification. On a partial update
(PATCH), a supplied source_record_metadata replaces the stored object
as a whole, and omitting it leaves the existing value in place.
Why it matters: Pipelines can attach and update per-source metadata — including access-control information — through the API.
Browse Agent Sessions in the Console
Selecting a session in the Console's agent sessions list now opens its full conversation in a resizable panel beside the list. The panel header includes Chat to open the session in the agent chat preview, View to open the full session view, and a control to close the panel.
Why it matters: You can review a session's conversation without navigating away from the list and losing your place.
Clearer Corpus Filter Errors in the Console
When you test an invalid metadata filter in the Console, the error now
names the problem instead of showing a generic "Filter expression has
errors" message. It suggests the closest matching key — for example,
Unknown filter key doc.catgory. Did you mean doc.category? — and flags
unquoted keys that contain spaces, dots, or dashes, showing the corrected
form (for example, doc.created at becomes doc."created at").
Why it matters: Filter mistakes are easier to spot and fix, with the Console pointing you to the likely correct key.
Google Drive and Google Docs Tools for Agents
Agents can now work with Google Drive and Google Docs through built-in tools. Drive tools search for files and get or put file content; Docs tools read a document, edit it, upload new content, and apply paragraph and text styling.
Why it matters: Agents can find, read, create, and format Google Drive and Docs content without custom integration code.
More information:
Filter Agent Aliases by Target Agent
Listing agent aliases now accepts an aliased_agent_key query parameter.
Passing an agent key returns only the aliases whose routing policy points
at that agent.
Why it matters: You can quickly discover which aliases route to a specific agent — useful when auditing routing or safely retiring an agent.
More information:
June 2026
Control Index Wait Behavior in the Document Index Tool
The document-index agent tool now takes a wait_for option.
searchable (the default) waits until the document is fully indexed and
immediately queryable — use it when a later step needs to search the
document right away. indexed returns as soon as the document is durably
stored and guaranteed to appear in future searches, which is faster and
more resilient when the indexing pipeline is busy.
Why it matters: Agents that index a document and immediately search it
can keep the default, while bulk-indexing agents can choose the faster
indexed mode.
More information:
Kubernetes Tools for Agents
Agents can now operate on Kubernetes clusters through a suite of
built-in tools: kube_get_resource, kube_list_resources,
kube_describe, kube_logs, kube_events, kube_apply,
kube_delete, kube_scale, and kube_rollout_restart. Cluster
authentication is pluggable, with providers for kubeconfig, OIDC, raw
tokens, and Amazon EKS credentials.
Why it matters: Operations and on-call agents can inspect workloads,
read logs and events, and apply controlled changes such as scaling or
restarting a rollout, without wrapping kubectl in custom tool code.
More information:
MCP File, Image, and Audio Results
Tools backed by the Model Context Protocol now surface non-text results. File bodies, images, audio, and resource links returned by an MCP server are passed through to the agent as artifacts instead of being dropped, so the agent can reason over the full result rather than text alone.
Why it matters: MCP tools that return documents, screenshots, or generated media are now fully usable from a Vectara agent, closing a gap where only the text portion of a result reached the model.
More information:
Bulk Document Metadata Update
A new endpoint applies a metadata change to many documents in a single
call: PATCH /v2/corpora/{corpus_key}/documents. Select documents
either by passing a comma-separated document_ids list (up to 10,000
per request) or by a metadata_filter expression such as
doc.status = 'archived' AND doc.year < 2020. The request body carries
the metadata object to apply and a strategy of merge (add or
overwrite only the supplied fields, the default) or replace (swap the
entire metadata object). The operation runs asynchronously by default
and returns a job_id you can track through the Jobs API, or set
async=false to wait for the updated_count, skipped_count, and
failed_count totals.
Why it matters: Re-tagging a large corpus previously meant fetching and re-writing documents one at a time. A single filtered update now reclassifies, archives, or corrects metadata across an entire corpus, which makes lifecycle and governance changes practical at scale.
More information:
GitHub Tools for Agents
Agents can now operate on GitHub repositories through a suite of 25
built-in tools covering files, commits, branches, issues, pull
requests, and search. Examples include github_get_file_contents,
github_push_files, github_create_pull_request,
github_get_pull_request_diff, github_create_issue,
github_add_issue_comment, github_search_code, and
github_update_ref. Each tool takes a github_token parameter that
you supply from an agent secret with an argument_override reference
like {"$ref": "agent.secrets.github_token"}, so the credential never
appears in the agent configuration or session history. The base URL is
configurable for GitHub Enterprise.
Why it matters: Coding and operations agents can read a repository, open and review pull requests, triage issues, and push changes without custom tool code. Paired with agent secrets, the GitHub token stays encrypted and is injected only at execution time.
More information:
More Pipeline Sources: Box, Confluence, and Wolken
Pipelines can now ingest from three additional source systems, each
selected by a type on the pipeline source configuration:
- Box (
type: box) walks a Box enterprise starting from afolder_idand inherits Box collaborations as document-level access control. It authenticates with a server-to-server Client Credentials Grant (client_id,client_secret,enterprise_id). - Confluence (
type: confluence) ingests pages from Confluence Cloud or Data Center (setdeploymentaccordingly), optionally scoped byspace_keys, and carries page read restrictions through as access control. - Wolken (
type: wolken_kb) ingests knowledge-base articles from Wolken ServiceDesk.
These join the existing s3, google_drive, sharepoint, and web
source types.
Why it matters: Each connector keeps the source system's own permissions attached to the ingested content, so a pipeline can pull from Box, Confluence, or Wolken without flattening access control or standing up an external crawler.
More information:
Glossary Tools for Agents
Two new tools let an agent manage glossary entries at runtime:
glossary_put_entries adds or updates term-to-expansion mappings, and
glossary_delete_entries removes them. Agents can now curate the same
glossaries that drive query expansion through the glossary_expansion
reminder.
Why it matters: Glossaries no longer have to be maintained out of band. An agent can capture a new acronym or product name it learns during a conversation and have it improve retrieval on the next query.
More information:
Agent Self-Scheduling with schedule_wakeup
A new per-session schedule_wakeup tool lets an agent schedule itself to
resume later. The agent supplies a delay_seconds, a prompt to deliver
back to the same session, and a reason. A later call moves the pending
wakeup earlier rather than stacking a second one, so an agent keeps at
most one scheduled resume per session.
Why it matters: Long-running and watch-style agents can wait on external state, then wake themselves to check again, without an external scheduler driving the loop.
More information:
Call Vectara Tools from Sandboxed Code
Lambda tools and sandboxed Python can now call other Vectara tools as
plain Python functions through a built-in tool module. A lambda
declares its own tool_configurations (inline or a reference to a
reusable configuration), then calls them as tool.<name>(param=value),
with tool.list() to discover what is callable and tool.ToolError
for failures. These composed tools are private to the lambda: they
never appear on the hosting agent's tool surface and produce no session
events. Any $ref to agent.secrets.* or session.metadata.* in a
composed configuration resolves against the hosting agent at execution
time.
Why it matters: A lambda can reach a credentialed REST API, search a corpus, or read an uploaded artifact while the sandbox itself stays without network access and never sees the underlying secret. To the agent, the lambda is still a single tool with one input and one output.
More information:
Plain-Text Agent Instructions
Agent instructions now accept a template_type of text in addition to
velocity. With text, the instruction is used verbatim as the system
prompt with no variable substitution, so prompts that contain literal
$ or # characters are no longer interpreted as template syntax.
Why it matters: Authors who do not need templating get predictable, literal prompts and avoid escaping. Velocity templating remains available for instructions that interpolate session or agent context.
More information:
Zoom Contact Center Connector
A Vectara agent can now serve as a Zoom Contact Center chatbot through a
new zoom connector, alongside the existing Slack and Google Chat
connectors. Zoom delivers inbound messages to the connector's webhook,
authenticated by a generated token in the x-zoom-connector-token
header. Replies are asynchronous: the webhook acknowledges with a typing
indicator and the agent's response is posted back to the Zoom-provided
callback URL when the run completes.
Why it matters: Customer-facing agents reach Zoom Contact Center without custom integration code, reusing the same agent definition, tools, and corpora that power your other channels.
More information:
Build Pipelines in the Console
Pipelines are now generally available in the Console, no longer behind a beta flag, and the no-code creation wizard covers more sources. You can configure Web, Google Drive, and S3 sources directly in the wizard, and S3 sources support include and exclude regex filters to scope exactly which objects are ingested.
Why it matters: Standing up a pipeline no longer requires the API. You can point Vectara at a website, a Google Drive, or an S3 bucket and tune what gets pulled in, all from the Console.
More information:
io: Build by Chatting in the Console
io is the AI assistant in the Vectara Console for building on the platform. Describe what you want in plain language and io scopes the work, inspects your account, proposes a configuration, and opens supported resources in the workspace. It can create and edit resources across the platform, including agents, pipelines, and API keys, and it answers questions about your account and the Vectara APIs. io never creates or updates a resource silently: for build requests it shows a confirmation card so you can review the draft, fix missing fields, and choose when to save.
Why it matters: Getting started no longer requires knowing which endpoint or Console screen to use. io turns an intent like "set up a scheduled pipeline that ingests my docs into a corpus" into a reviewable draft, while keeping you in control of what actually gets written.
More information:
Reusable Tool Configurations
A reusable tool configuration is a tool setup, such as a corpora search
bound to specific corpora or a web search with domain filters, that you
define once and attach to any number of agents by a key you choose.
Manage them with the /v2/tool_configurations endpoints, then attach
one to an agent with a reference entry in the agent's
tool_configurations map instead of restating the same configuration
inline on every agent.
Why it matters: Shared configurations remove copy-paste drift across a fleet of agents. Update the definition in one place and every agent that references it picks up the change.
More information:
Google Chat Connector
A Vectara agent can now serve as a Google Chat app through a gchat
connector, joining the existing Slack connector, and you can configure
it directly in the Console. Google Chat delivers inbound messages to the
connector's webhook and the agent replies in the same space or thread,
reusing the agent's existing instructions, tools, and corpora.
Why it matters: Teams that work in Google Chat get a Vectara agent in the tools they already use, with no custom integration code and the same agent definition that powers your other channels.
More information:
Updated Corpora Search Tool
A new dated version of the agent retrieval tool, corpora_search_20260608,
is available. It resolves corpus document tables lazily, lets image and
table results carry the matched snippet, and returns retrieved results
without an auto-generated summary. Existing corpora_search configurations
keep working unchanged; pin the dated version to opt in.
Why it matters: Dated tool versions let retrieval behavior evolve without breaking agents that depend on the current shape. The newer version is leaner for agents that do their own synthesis over results.
More information:
One Result per Document and Full-Document Context
Two query options give you more control over what retrieval returns.
Setting max_by to doc.id collapses the result set so at most one
result comes back per document, keeping the highest-scoring part of
each. Setting full_document_context to true in the context
configuration returns the entire document that contains a matching part
as context, in which case the characters_before/characters_after
and sentences_before/sentences_after windows are ignored.
Why it matters: Collapsing by document avoids burying distinct sources behind several parts of the same document, and full-document context hands the generator the whole source when a narrow window would cut off the answer.
More information:
Account Switcher
The Console can now switch between multiple accounts without logging out. Add accounts you have access to, then move between them from the account switcher, including single sign-on re-authentication where required.
Why it matters: Users who work across several accounts, such as partners and multi-tenant administrators, no longer have to log out and back in to change context.
Observability: Metrics and Traces
The Console has a new Observability view that brings agent metrics and traces together under one set of filters. A shared bar scopes both tabs by agent and time range (last hour, 24 hours, 7 days, 30 days, or a custom window). The Metrics tab charts trace volume, duration percentiles, error counts, token usage (including cache reads), active sessions, and tool-call metrics. The Traces tab lists agent runs and drills into per-span detail, filterable by status, error type, operation, tool name, and duration.
Why it matters: Operating an agent in production no longer means stitching together separate dashboards. One surface answers both "how is this agent behaving over time" and "what exactly happened in this run."
More information:
Image Embeddings for Visual Retrieval
Image-capable corpora can now embed the image parts of a document, not just its text. When a corpus uses a vLLM-shaped HTTP encoder that supports images, indexing encodes each image part inline so the corpus retrieves over visual content such as diagrams, charts, and scanned pages.
Why it matters: Documents whose meaning lives in figures and screenshots become retrievable by what they show, rather than relying on nearby text. This pairs with visual data ingestion to bring image-heavy content into search.
More information:
Document Ingestion Agent Tools
The document-ingestion tool suite for agents is now generally available, out of experimental status, with added support for spreadsheets. Agents can convert Excel workbooks to indexable documents, analyze a document's structure, and reindex content, using standardized part metadata across formats.
Why it matters: Agents that build and maintain corpora can ingest a wider range of source files, including spreadsheets, and re-process content as part of a normal tool workflow.
More information:
Agent Aliases
Agents can now sit behind an alias, a stable public name that routes each new
session to an underlying agent according to a policy you control. Callers create
sessions with POST /v2/agent_aliases/{alias_key}/sessions and the alias's
routed policy decides which agent owns the session. A policy is an ordered list
of rules, each with an optional match expression and either a single target
or a weighted split across agents. Routing resolves once at session creation
and the resolved agent_key is fixed for the life of the session.
Why it matters: Without an alias, every caller hardcodes a specific
agent_key, so changing which agent serves traffic means redeploying every
caller. An alias moves that decision to the server, enabling canary rollouts by
weight, tenant routing by session metadata, and stable handles in front of
agents whose configuration evolves, all without changing client code.
More information:
May 2026
Tool Input Transforms
Tools now support an input_transform field — a jq expression applied
to the tool's input after argument overrides are merged but before the
tool is invoked. The transform receives context including agent,
session, tools, currentDate, and the merged args, enabling
server-side input reshaping such as injecting bearer tokens from agent
secrets, pulling corpus keys from session metadata, or appending query
suffixes. Expression failures are reported to the agent as tool errors.
Why it matters: output_transform (released May 6) lets you trim
what comes back from a tool; input_transform completes the picture by
letting you reshape what goes in. Together they give full control over
the tool boundary without writing custom tool code.
More information:
Web Source for Pipelines
Pipelines can now ingest pages directly from websites using a new web
source type with three discovery modes: sitemap reads URLs from one
or more sitemaps with per-URL change detection via <lastmod> tags;
crawl performs breadth-first link-following from seed URLs; and
sitemap+crawl combines both. All modes support politeness controls
(request rate, concurrent connections, robots.txt), page count caps,
JavaScript rendering for SPAs via a headless browser service, and
authentication.
Why it matters: Before web source, getting website content into a pipeline required an external crawler writing to S3. Web source handles discovery, deduplication, and rendering natively, so you can point a pipeline at a site and let the agent decide how to process each page.
More information:
Image Analysis Tool
A new image_analysis tool enables agents to extract and analyze
visual content from image artifacts using vision-capable LLMs. The
tool supports configurable detail levels (auto, low, high) and
preprocessing options including upscaling, tiling for large images,
contrast enhancement, and sharpening — optimized for text-dense
content like diagrams, tables, and scanned documents.
Why it matters: Agents could already receive image artifacts, but had no built-in way to reason about their contents. The image analysis tool closes that gap, particularly for workflows that mix document text with charts, screenshots, or scanned pages.
Agent Secrets
Agents now have a dedicated, encrypted secrets resource at
/v2/agents/{agent_key}/secrets. Write credentials once via
PUT or PATCH, then reference them from any tool's
argument_override as {"$ref": "agent.secrets.<name>"}. The
plaintext is passed into the tool at execution time and replaced
with "****" everywhere else — on GET, on the response of
the write itself, and inside the tool_input events emitted on
the session.
Three endpoints, all gated to owner / administrator /
agent_administrator:
GET /v2/agents/{agent_key}/secrets— list secret names with masked values.PUT /v2/agents/{agent_key}/secrets— replace the full set. Names not in the request are removed.PATCH /v2/agents/{agent_key}/secrets— add or replace individual names, or remove a name by mapping it tonull.
Why it matters: Before this, the only places to put a Jira
token or Slack webhook URL were agent.metadata or a literal
value in argument_override — both of which GET /v2/agents/{agent_key}
returns in plaintext to any caller with read access on the agent.
Secrets live on a separate resource, are encrypted at rest, and
never come back as plaintext on a read. Existing agents keep
working; migrate them by writing the credential to the new
endpoint and switching the tool's argument_override to a $ref.
More information:
Throttled Reminders and Tool Output Transforms
Two upgrades for keeping long agent sessions on the rails without blowing up token cost.
Throttled reminders. Templated reminders now accept fire_every
(fire on every Nth matching event) and skip_first (skip the first N
matching events at session start). Combine them to delay a reminder
until the conversation has gone on long enough for the system prompt
to fade from the model's effective attention, then keep it firing
infrequently. Counters reset after a session compaction, so the
warmup applies again to each fresh stretch of conversation.
Tool output transforms. Every tool configuration now accepts an
optional output_transform: a jq expression applied to the tool's
JSON response before it reaches the LLM. Use it to project, filter,
or summarize verbose tool output — especially useful for search tools
that return scoring metadata, provider envelopes, and fields the
agent will never cite. Pairs naturally with web_get: trim
web_search to title/url/snippet so the agent can pick a result, and
let it fetch only the page it actually wants to read.
Why it matters: Long agentic sessions hit two predictable failure modes — instructions decaying from the system prompt as turns pile up, and tool responses crowding out useful conversation history. These features address both directly, with knobs that let you tune the trade-off per agent rather than rewriting prompts.
More information:
Pipeline Run Cancellation
Pipeline runs can now be cancelled mid-flight via
POST /v2/pipelines/{pipeline_id}/runs/{run_id}/cancel. In-progress
record processing finishes gracefully; queued records stop being
dispatched and the run transitions to a terminal cancelled state.
Why it matters: Long-running ingest jobs that turn out to be mis-targeted (wrong filter, wrong source revision, runaway agent loop) no longer have to be waited out. Cancel from the API, fix the configuration, and re-run.
More information:
LIKE Operator for Filter Expressions
Filter expressions now support SQL-style LIKE pattern matching on
text metadata columns. Patterns use standard wildcards: % matches
zero or more characters, _ matches exactly one character, and
backslash escaping (\%, \_, \\) matches literal characters.
Why it matters: Until now, metadata filters were limited to exact
match, range, and IN comparisons. LIKE adds substring and pattern
matching — useful for filtering on partial document IDs, URL prefixes,
or naming conventions without needing a separate metadata field for
each pattern.
Configurable LLM Stream Idle Timeout
CreateOpenAILLMRequest, CreateAnthropicLLMRequest, and
CreateVertexAILLMRequest now accept an optional
idle_timeout_seconds field. The platform terminates the SSE
connection if no new server-sent event arrives within this window.
When unset, the platform falls back to its default read timeout for the provider — typically 60 seconds for OpenAI and Anthropic, the SDK default for Vertex. Maximum is 3600 seconds.
Why it matters: Reasoning-heavy models, long-running tool calls, and large continuous outputs can pause for longer than the default read timeout, surfacing as a stream error in the agent loop. Raising the idle timeout gives the model room to think without the platform killing the connection underneath it.
April 2026
Tool-Output Offloading: Truncate Mode and Headroom Gate
Two upgrades to tool-output offloading make it work for every agent, not just ones with artifact tools configured.
mode: truncateshortens large tool outputs in place, keeping the head and tail and replacing the middle with a short omission notice. No artifact is created and no extra tool round-trip is needed. Mode auto-selects:artifactwhen the agent has any ofartifact_read/artifact_grep/artifact_jqconfigured,truncateotherwise.headroom_percentageis a new cumulative-context gate. When adding a tool output would push total input tokens above this fraction of the context window (default 0.70), the output is offloaded even if it would otherwise be small enough to pass through. This catches the case where many medium-sized outputs pile up over a session.
Offloading is now on by default for every agent (default
enabled: true), and the default context_percentage was raised
from 0.05 to 0.25 to better match per-output size against modern
context windows.
Why it matters: Agents without artifact tools previously had no protection against runaway tool outputs. Truncate mode gives them a zero-config safety net. The headroom gate addresses the slow-burn failure where context fills up across many tool calls without any single output being obviously too big.
More information:
SharePoint Connector
A new SharePoint connector enables ingesting files from SharePoint
document libraries via Microsoft Graph using app-only Azure AD
authentication. The connector uses Graph's /delta change-tracking
endpoint for reliable enumeration of new and modified files, supports
folder-scoped ingestion, automatic deduplication via watermarks, and
lazy-loaded custom column metadata.
Why it matters: SharePoint is where many enterprises keep their documents. The connector brings that content into Vectara pipelines and agent workflows without requiring an external ETL step or manual export.
Agent Traces
A new Agent Analytics surface for inspecting what an agent actually did. Every agent invocation now produces a trace: a tree of spans covering each LLM call, tool execution, guardrail check, step transition, compaction, and image read, with timing, token usage, status, and (optionally) the decrypted input/output content.
Four endpoints are available:
GET /v2/agent_analytics/traces— list traces with filters for agent, session, status, error type, operation, tool name, tool error type, time range, and duration thresholds.GET /v2/agent_analytics/traces/{trace_id}— fetch a trace summary.GET /v2/agent_analytics/traces/{trace_id}/spans— list spans for a trace, withinclude_content=trueto retrieve the underlying messages and tool arguments.GET /v2/agent_analytics/traces/{trace_id}/spans/{span_id}— fetch a single span.
Why it matters: Debugging agent behavior in production has been mostly guesswork. Traces give you an exact reconstruction of what the model saw, what tools it called, what they returned, and where time and tokens went — filterable down to "which traces hit a timeout in this tool" or "which sessions exceeded the context limit."
More information:
Glossaries
Agents can now expand internal acronyms, product codenames, and team
names from user messages using shared glossaries. Create a glossary of
term-to-expansion mappings once, attach it to an agent step as a
glossary_expansion reminder, and the agent receives a hint block
listing the expansions for every matching user message.
Why it matters: Enterprises have vocabulary that LLMs have no way to guess — "k8s," "PodA," "Project Atlas." Glossaries let you teach an agent that vocabulary in one place, reused across every agent and every session, without bloating the system prompt.
More information:
Pipelines
Automate bulk processing of data from external sources through agents. A pipeline pulls records from a source (S3 today, with more source types in the pipeline), spawns a fresh agent session for each record, and lets the agent decide what to do: index the record into a corpus, extract structured data, route it somewhere, or discard it. Failed records land in a dead-letter queue for retry.
Why it matters: Continuous data ingest and bulk document processing are common enterprise use cases that previously required external orchestration. Pipelines put the full flexibility of an agent behind a managed ingest loop — no cron jobs, no queue workers, no retry infrastructure to build yourself.
More information:
Agent Identity
Agents now have their own dedicated identity. Previously, an agent executed tools and accessed resources using the identity of whoever invoked it. Now each agent has its own service account with independently configurable permissions.
Why it matters: When agents ran as the calling user, every user needed permissions for everything the agent might do, and there was no way to restrict what the agent itself could access. With dedicated agent identities, you grant the agent exactly the permissions it needs — regardless of who triggers it.
March 2026
Context Compaction for Agent Sessions
Long-running agent sessions can now automatically compact their context. When a session approaches LLM token limits, compaction summarizes older events while preserving key information. You can also fork a session without compaction to branch a conversation.
Why it matters: Before compaction, long conversations would hit token limits and fail. Now agents can maintain coherent, extended conversations — useful for research sessions, ongoing customer support threads, or multi-day workflows that accumulate significant context.
More information:
Tool Versioning and Metadata
Tools now support category, lineage, version, and tool group metadata. You can mark tools as experimental and track how tools evolve across versions.
Why it matters: As your tool library grows, versioning prevents breaking changes from affecting running agents. You can deploy a new version of a tool, test it with experimental agents, and promote it when ready — without disrupting production workflows.
More information:
Tool-Output Offloading
Tools that return large payloads — multi-megabyte API responses, long
database dumps, full document text — no longer blow through your
agent's context window. When a tool's output exceeds a configurable
threshold, the platform writes it to a session artifact and hands the
agent a compact reference instead. The agent reads back what it needs
using artifact_read, artifact_grep, or artifact_jq.
Offloading turns itself on by default whenever the agent has
artifact_read configured, so most agents get the protection for
free.
Why it matters: One runaway tool response can poison an entire session, forcing the agent to spend its context budget on output it mostly doesn't need. Offloading isolates the blast radius: the agent keeps working, the prompt stays tight, and the full output is still available on demand.
More information:
February 2026
Agent Reminders
Agent steps can now carry reminders — short pieces of text that are automatically re-injected into every user input or tool output the agent sees. Reminders are how you counteract the LLM's recency bias on long sessions: a rule written once at turn 1 effectively disappears by turn 40, but a reminder keeps it near the end of the prompt where the model is still paying attention.
Why it matters: Instructions alone drift as conversations grow. Reminders let you re-assert critical constraints, dynamic per-user context, or format requirements on every turn, so the agent stays on track even across long or multi-device sessions.
More information:
- Reminders
- Glossaries — a specialized acronym-expansion reminder.
Multi-Step Agent Workflows
Agents now support multi-step workflows. Define named steps, each with its own instructions, available tools, and reminders. Steps transition based on configurable conditions.
Why it matters: Steps give you fine-grained control over an agent's behavior during a turn. Each step can have different instructions and capabilities, so you can precisely shape what the agent does at each phase of its work.
More information:
Agent Schedules
Schedule agents to execute automatically at specified intervals. Each scheduled run creates a new session, and you can view the execution history to monitor results.
Why it matters: Many agent use cases are recurring — daily report generation, periodic data quality checks, or scheduled content updates. Schedules eliminate the need for external cron jobs or orchestration tools.
More information:
Agent Skills
Organize agent capabilities into named skills that can be invoked explicitly. Skills let you direct an agent to use a specific capability rather than relying on the LLM to choose.
Why it matters: When agents have many tools, the LLM sometimes picks the wrong one. Skills give you deterministic control — invoke exactly the capability you need, especially useful for programmatic agent interactions where you know the intent upfront.
More information:
Concurrent Agent Sessions
Multiple clients can now interact with and interrupt an ongoing agent session simultaneously. This enables collaborative workflows where users and systems share a live agent session.
Why it matters: You can now steer agents mid-response — queue up follow-up messages while the agent is still working, interrupt it if it's heading in the wrong direction, or redirect its focus without waiting for it to finish. This makes agent interactions feel responsive and controllable, especially for long-running tool calls or multi-step workflows where you need to course-correct in real time.
More information:
January 2026
Structured Outputs for Agents and LLMs
Agents and LLMs can now return responses conforming to a JSON schema you define. Specify the expected output structure when creating an agent or making a chat completion request, and the response will be validated against your schema.
Why it matters: Parsing free-text LLM output is fragile and error-prone. Structured outputs guarantee the response shape, making it straightforward to feed agent responses into downstream systems, databases, or APIs without custom parsing logic.
More information:
Bulk Delete Documents
Delete multiple documents from a corpus in a single asynchronous API call. The operation runs as a background job and you can track its progress through the Jobs API.
Why it matters: Cleaning up large datasets previously required deleting documents one at a time. Bulk delete makes corpus maintenance practical for large-scale deployments where you regularly need to remove outdated or incorrect content.
More information:
Web Get Tool
Agents can now fetch arbitrary URLs using the new web_get tool.
Given any URL, the tool makes an HTTP request and returns the response
content for the agent to reason over. This works with web pages, REST
APIs, webhooks, and any HTTP-accessible endpoint.
Why it matters: web_get turns agents into general-purpose HTTP
clients. Beyond reading web pages, agents can call external REST APIs,
pull data from internal services, trigger webhooks, or fetch structured
data from any HTTP endpoint. Combined with structured outputs and
lambda tools, this makes it possible to integrate agents with virtually
any web-accessible system without writing custom tool code.
More information:
Fuzzy and Prefix Metadata Search
The metadata query API now supports fuzzy and prefix matching on field values. Find documents even with approximate or partial metadata matches.
Why it matters: Exact-match metadata filters miss documents with typos, abbreviations, or variant spellings. Fuzzy and prefix search makes metadata filtering more forgiving and practical for real-world data where values aren't perfectly normalized.
More information:
December 2025
Voice AI with Speechmatics Integration
Vectara now integrates with Speechmatics for building real-time voice agents. Combine Speechmatics' real-time speech-to-text (less than 1 second latency, and 55+ languages) and text-to-speech (TTS) with Vectara's RAG capabilities to create AI assistants that see, hear, and speak.
Why it matters: Voice interfaces are becoming essential for accessible AI experiences. This integration delivers accuracy with ultra-low latency, making it practical to build production voice agents that can answer questions from your knowledge base in real-time.
More information:
November 2025
Sub-agents: Autonomous, Specialized Agents Inside Your Agents
Vectara introduces sub-agents, a powerful new capability that lets your agents initialize dedicated, autonomous agent instances to handle additional, multi-step tasks. They accomplish all of this while keeping their context isolated from the parent agent conversation. Invoke autonomous agents for focused tasks such as code review, research, or content transformation.
Why it matters: Advanced sessions often overwhelm an agent and cause context bloat. Sub-agents solve this issue by providing a separation from the primary agent. Your parent agent stays focused while delegating work to highly specialized sub-agents that maintain an independent state, reasoning, and workflow.
More information:
Document Conversion Tool for Agents
Vectara introduces the Document Conversion Tool, a new standalone agent tool that extracts content from uploaded files and converts them into clean, structured Markdown format. These files include PDFs, Word documents, PowerPoint presentations, and images. The tool includes OCR capabilities for extracting text from images. Converted outputs persist across a session.
Why it matters: Previously, converting uploaded files into readable text required external preprocessing. This tool brings document parsing and OCR directly into agent sessions, enabling agents to interpret file types and transform them into context-ready text for reasoning, summarization, or indexing.
More information: Agent tools overview Document upload and conversion
November 15, 2025
The Agents API now supports artifact storage, a persistent, session-scoped workspace for files that enables efficient multi-step document processing workflows. Artifacts provide a persistent workspace where agents and users can share files throughout a conversation without bloating the agent's context. Agents support multi-modal analysis through image artifacts (PNG, JPEG, GIF, WebP) alongside document formats. When the session expires, the artifacts are cleaned up.
Why it matters: Before artifact storage, file uploads caused context window bloat and inefficient multi-step workflows. Artifacts solve these problems by separating file storage from file references. Upload a PDF or image once, and reference it across multiple operations like conversion, visual analysis, and indexing.
What's new:
- Session-scoped storage: Files uploaded to agent sessions are stored as artifacts with unique identifiers, remaining available throughout the conversation lifecycle.
- Multi-modal support: Upload and analyze both documents and images in the same session workspace.
- Lightweight references:
ArtifactReferenceobjects contain only metadata (artifact_id, filename, mime_type, size_bytes) instead of full file contents, reducing payload sizes from potentially megabytes to ~100 bytes.
More information:
Web Search Tool Enhanced with Domain Filtering
The Web Search tool now supports domain-level filtering, enabling more precise and configurable search behavior. You can restrict results to specific domains or exclude domains entirely, including support for subdomains and wildcard patterns.
Why it matters: This enhancement gives agents more control over source quality and relevance. You can now constrain web search behavior to trusted domains or remove undesirable, or low-value sources.
More information: Agent tools overview
October 2025
Lambda Tools: Customize Python Functions in Agents
Vectara introduces the tech preview of Lambda Tools, extending agent capabilities with your own Python functions. Lambda Tools let agents execute custom business logic, calculations, or data transformations in secure, sandboxed environments.
Why it matters: Lambda Tools let you safely plug in your own logic so agents can perform domain-specific actions like scoring leads, analyzing data, or applying compliance checks, all without leaving the Vectara environment. Each function runs in an isolated Python sandbox with automatic schema discovery, resource limits, and full audit logging for transparency and governance.
New API endpoints:
- Create a Lambda Tool
- Test a Lambda Tool - This lets you test the tools you already created.
- Test Lambda Tool - This lets you test functions before creating and using them with agents.
- Update a Tool
- List Tools
More information:
September 2025
Vectara Agents Framework
We're excited to introduce the tech preview of the Vectara Agents APIs. This comprehensive framework enables building intelligent, autonomous AI agents that go beyond simple question-answering, to become configurable digital workers capable of complex reasoning, multi-step workflows, and enterprise system integration.
Why it matters: Traditional RAG applications are limited to reactive Q&A interactions. The Agents APIs enable AI agents that can autonomously reason through problems, orchestrate multiple tools, maintain conversation context, and integrate with enterprise systems through standardized protocols. This opens entirely new use cases for AI automation, from intelligent customer support to complex business process orchestration.
What's new:
- Agents APIs: Create and configure intelligent agents with customizable reasoning models, behavioral instructions, and tool access controls
- Stateful Conversations: Maintain context across multi-turn interactions with session management, enabling complex dialogues and workflow continuity
- Tool Orchestration: Agents can dynamically invoke multiple tools including:
- Corpora search for RAG capabilities
- Web search for real-time information
- Custom MCP tools for enterprise integrations
- Streaming Response Support: Real-time conversational experiences with Server-Sent Events for progressive response building
- Flexible Instructions: Combine reusable instruction templates with inline configurations using Velocity templating for dynamic agent behavior
- Chain-of-Thought Reasoning: Transparent agent thinking process with dedicated event types for reasoning visibility
- Version Management: Instructions and tool configurations support versioning for controlled rollouts and governance
New API Endpoints:
The Vectara Agent APIs introduce several new endpoints:
More information:
:::caution
- This is a tech preview release. APIs and features may evolve based on customer feedback.
- All agent and session identifiers follow the pattern
[0-9a-zA-Z_-]+without prefixes. - MCP is the only supported tool server protocol in this release. :::
August 2025
Fuzzy Metadata Search
Vectara introduces the tech preview of Fuzzy Metadata Search across document metadata fields. This capability automatically handles spelling errors and variations when searching metadata like titles, authors, categories, or custom attributes—dramatically improving document discovery rates in large repositories.
Why it matters: Traditional exact-match filtering misses relevant documents due to data entry inconsistencies or user typos. Fuzzy Metadata Search solves this by applying intelligent matching algorithms that find "Employment Agreement" even when users search for "Employement Agrrement", making document discovery more forgiving and effective.
Key capabilities:
- Multi-field weighted search with customizable importance scores
- Two-stage processing: exact pre-filtering followed by fuzzy matching
- Automatic handling of typos, transpositions, and spelling variations
- Support for both document-level and part-level metadata
New API endpoint:
More information:
Vectara Postman Collection: Faster API Exploration and Testing
Vectara published the official Postman Collection, giving developers an easy, code-free way to explore and test the Vectara REST APIs. The collection includes pre-configured requests for common operations, such as creating corpora, indexing documents, and running semantic searches—organized into folders for quick navigation. It supports both API key and OAuth 2.0 authentication, making it flexible for rapid prototyping or secure production workflows.
Why it matters: Getting started with a new API can involve a lot of trial and error. The Vectara Postman Collection provides ready-to-use requests and example payloads, so you can focus on experimenting with Retrieval-Augmented Generation (RAG) workflows and integrating them into your applications faster. Whether you’re building a proof-of-concept or refining a production integration, Postman makes it easy to interact with Vectara’s endpoints, inspect responses, and iterate on your requests in real time.
What’s new:
- Official Vectara Postman Collection published on the Postman API Network.
- Pre-configured requests for creating corpora, indexing documents, querying
data, and managing resources. - Authentication support for API key and OAuth 2.0 (Client Credentials)
flows. - Organized folders for Corpora Management, Indexing, Querying, and
Administration. - Sample payloads and parameters included for faster learning and testing.
More information:
July 2025
Vectara Admin Center: Centralized Control for On-Premise and VPC Deployments
Vectara introduces the Admin Center, a unified interface designed to streamline the management of on-premise and VPC deployments. The Admin Center empowers DevOps and IT Admin teams with comprehensive visibility and control, helping prevent RAG sprawl and reducing operational overhead.
Why it matters: Managing AI infrastructure on your own servers demands clarity, efficiency, and tight access control. The Vectara Admin Center centralizes administrative operations, enabling teams to monitor system health, manage tenants and users, register LLMs, and track resource usage from a single dashboard. This reduces manual effort, improves security, and gives organizations the flexibility to scale and optimize their Vectara environment with confidence.
What’s new:
- System Health Monitoring: Instantly view the overall status of your Vectara deployment, including tenants, queries, and indexing activity.
- Tenant & User Management: Easily manage tenant accounts, user permissions, and quotas through a streamlined interface.
- Model Registration: Centrally register and manage custom Large Language Models (LLMs) for consistent usage across all teams.
- Corpus Oversight: Quickly audit corpora within any tenant, with options to rebuild or resolve issues for optimal performance.
- Bug Reporting: Collect relevant logs and generate detailed bug reports to accelerate troubleshooting and support.
More information:
Vectara Python SDK Documentation
Vectara now offers comprehensive documentation for the new Vectara Python SDK, making it easier than ever to integrate Vectara’s platform with Python-based applications. The SDK streamlines common tasks such as authentication, query management, and response handling, all while using familiar Python patterns.
Why it matters: Python is the go-to language for many AI and data engineering teams. With this SDK and the new documentation, developers can get started faster, implement best practices with less effort, and focus on building solutions instead of boilerplate code.
What you’ll learn:
- How to install and configure the Vectara Python SDK
- Key methods for querying, indexing, and retrieving data
- Authentication and security best practices
- Tips for handling responses, errors, and pagination
- Example workflows for RAG and generative AI applications
More information:
Vectara Python SDK Documentation Vectara Python SDK on GitHub
Open RAG Eval: Consistency-Adjusted Index for RAG System Evaluation
The Open RAG Evaluation tool now offers the consistency-adjusted index to evaluate both the quality and consistency of responses generated by RAG systems. This metric assesses the strength of the answers, and also how reliably the system produces those high-quality results when faced with repeated queries.
Why it matters: In production and enterprise scenarios, consistency is as important as accuracy. The consistency-adjusted index combines both quality and stability into a single, actionable score. This metric enables you to quickly identify when your RAG system is delivering trustworthy results, and when variability or lower quality requires further attention. A higher index means your system reliably produces high-quality responses, while a lower index indicates the need for deeper investigation and improvement.
More information:
June 2025
VHC Enhanced for Query-Aware Hallucination Detection and Correction
Vectara has enhanced the Hallucination Corrector (VHC) API with support for query-aware hallucination detection and correction. This upgrade introduces the ability to include the original user query in VHC requests, enabling more accurate analysis of model-generated text.
Why it matters: In RAG workflows, generated responses often reflect both the retrieved context and the phrasing or intent of the user query. Adding the optional query field to VHC requests enables the model to interpret response formatting better. This helps resolve ambiguities, and attribute facts that are inferred from the query rather than only the source. This results in improved correction accuracy, particularly for instructions like “Answer True or False,” “List the top 3,” or “Summarize concisely.”
What’s new:
- The
modelparameter has been renamed tomodel_name, - Added an optional
queryfield for VHC requests to activate a query-aware prompt. - Improved correction precision in prompt-sensitive use cases
More information:
HHEM 2.3 - Additional Language Support and Enhanced Architecture
Vectara’s Hughes Hallucination Evaluation Model (HHEM) now supports three additional languages: Russian, Japanese, and Hindi. This update increases the total supported languages from 8 to 11, further enhancing accessibility and global usability.
Languages now supported: English, German, French, Spanish, Portuguese, Arabic, Chinese (Simplified), Korean, Japanese, Hindi, and Russian.
This release also introduces a significant update to HHEM’s architecture, resulting in reduced operational costs and improved performance and accuracy.
Why it matters: By expanding multilingual support, Vectara further reduces reliance on manual translations, enabling global teams to directly evaluate AI accuracy in their native languages. The enhanced architecture delivers cost-effective performance improvements, promoting broader, confident adoption of trustworthy AI solutions.
More information:
May 2025
Vectara Hallucination Corrector (VHC) API
Vectara introduces the tech preview release of the Vectara Hallucination Corrector
(VHC) API, a new capability designed to evaluate and revise AI-generated
summaries for factual accuracy. The VHC endpoint compares a generated summary
to one or more source documents and returns a corrected version, applying only
the minimal changes needed to align the summary with the source material.
Why it matters: In Retrieval Augmented Generation (RAG) workflows, LLMs commonly introduce inaccuracies or hallucinations. The Vectara Hallucination Corrector offers a targeted solution by enabling automatic, explainable corrections to text based on reliable context—preserving the original phrasing wherever possible. This improves trust, precision, and usability of AI-generated outputs across enterprise applications.
New API endpoints:
More information:
April 2025
Chat Completions API
Vectara now offers an OpenAI-compatible Chat Completions API, enabling seamless integration of Vectara’s language models into applications already built for OpenAI’s chat endpoint. This API supports both synchronous and streaming response formats and adheres to the familiar message-based interface used for conversational AI.
Why it matters: Developers can now integrate Vectara’s models into chat interfaces, agents, and customer-facing applications without needing to rearchitect prompt flows or backend systems. The compatibility layer makes it easy to switch between providers or test performance across models, all while tracking usage and applying fine-grained generation controls.
New API endpoint:
Evaluate Factual Consistency API
Vectara introduces the tech preview of the Evaluate Factual Consistency API, a new endpoint that assesses how well a generated summary or response aligns with its supporting source documents. This API provides a confidence score indicating whether a given text is grounded in the referenced material—helping developers detect and respond to hallucinated content in LLM outputs.
Why it matters: As enterprises rely more heavily on generative AI for summarization, Q&A, and knowledge tasks, the ability to detect factual inconsistencies becomes critical. This API enables automated quality control by scoring alignment between generated text and source documents, improving the reliability and auditability of AI-generated content.
New API endpoint:
Mockingbird 2: Vectara's Advanced LLM for RAG
Vectara releases Mockingbird v2, an advanced Large Language Model (LLM) optimized for Retrieval Augmented Generation (RAG) with cross-lingual capabilities. Mockingbird v2 introduces support for queries, documents, and summaries in different languages, enhanced generation quality, and robust hallucination mitigation, making it ideal for global enterprise applications.
Why it matters: Mockingbird v2 enables organizations to process multilingual datasets seamlessly, delivering precise summaries across English, Spanish, French, Arabic, Chinese, Japanese, and Korean. With a 0.9% hallucination rate in its Mockingbird-2-Echo configuration, it ensures trustworthy outputs for research, knowledge bases, and question-answering systems.
More information:
Custom Table Summarization with Prompt Templates
Vectara now supports custom prompt templates for table summarization during
document upload. This enhancement enables users to define exactly how extracted
table data should be summarized using an OpenAI-compatible LLM. The
prompt_template is configured with the table_extraction_config parameter
in the File Upload API and supports Apache Velocity syntax for referencing
table structure and content.
Why it matters: If you work in a domain with structured tabular data, summarizing tables with LLMs can surface key insights automatically. This capability allows you to tailor how summaries are generated by injecting domain-specific language, tone, and formatting preferences—resulting in more relevant, actionable outputs.
Updated API Endpoint:
More information:
March 2025
Expanded Encoder Management
Vectara introduces the Create Encoder API, allowing users to register and configure custom text embedding encoders for seamless integration within the Vectara platform. This API supports OpenAI-compatible encoders, enabling users to define authentication details, model parameters, and API endpoints for enhanced embedding workflows.
Why it matters: Organizations using AI-powered search and retrieval applications can now manage multiple encoder configurations tailored to their specific needs. This capability provides greater flexibility in defining custom embedding models, optimizing similarity search, document retrieval, and other AI-driven use cases.
New API Endpoint:
Vectara Kafka Connect Plugin Integration
Vectara introduces the Vectara Kafka Connect Plugin, enabling seamless real-time integration between Confluent Cloud and Vectara. This plugin enhances data streaming capabilities by providing scalable, schema-aware processing for efficient vector search workflows.
Why it matters: This integration allows organizations to leverage real-time data ingestion for AI-powered search, recommendation engines, and advanced analytics, optimizing knowledge retrieval from streaming data.
More information:
February 2025
Integrate External Large Language Models (LLMs)
Vectara introduces the tech preview of the Create LLM API, enabling users to integrate and configure external Large Language Models (LLMs) for use with query and chat endpoints. This API enables connectivity with models compatible with OpenAI API specification, including Anthropic Claude, Azure OpenAI, and custom-hosted LLMs.
compatible with OpenAI API specification
Why it matters: "Organizations need control over the LLMs they use in AI application development, including configuration, authentication, and deployment. This capability provides that flexibility by allowing users to connect external LLM providers, define authentication methods, and specify model parameters and API endpoints—all within a single API.
New API endpoint:
Document Summarization API
Vectara introduces the tech preview release of the Document Summarization, enabling users to generate concise summaries from lengthy documents such as technical reports, vendor quotes, and financial statements. This API helps streamline information retrieval by allowing users to extract key insights without manually reviewing entire documents.
Why it matters: The Document Summarization API addresses a critical need for organizations dealing with large volumes of unstructured content. By leveraging Retrieval Augmented Generation (RAG), users can generate summaries that capture the most relevant information, significantly reducing time spent on document analysis.
New API endpoint
Intelligent Query Rewriting
Vectara introduces the tech preview release of Intelligent Query Rewriting, a capability that enhances search accuracy by automatically generating metadata filter expressions from natural language queries. This innovation enables users to search naturally while ensuring more precise results by applying context-aware filters in the background.
Why it matters: Intelligent Query Rewriting bridges the gap between natural language queries and structured data, improving search precision without requiring user intervention. It reduces query refinement time, streamlines workflows, and provides full transparency by including generated filters and rephrased queries in the API response and query history.
More information:
January 2025
Knee Reranking
Vectara now offers Knee Reranking, an advanced dynamic filtering tool designed to improve the precision of query results by automatically identifying natural cutoff points between relevant and irrelevant results. This feature integrates seamlessly into Vectara's reranking chain, following the Slingshot reranker (Vectara Multilingual Reranker V1), to refine search outputs with advanced score pattern analysis.
Why it matters: Knee Reranking elevates the quality of retrieval in Retrieval Augmented Generation (RAG) systems by adapting to the unique score distribution of each query dynamically. By automatically filtering out less relevant results, users receive more focused and actionable results, and experience reduced latency and improved accuracy from limiting irrelevant data sent to downstream systems.
More information:
HHEM 2.2 - Expanded Language Support
Vectara’s Hughes Hallucination Evaluation Model (HHEM) now supports five additional languages: Portuguese, Spanish, Arabic, Chinese, and Korean. This update increases the total supported languages from 3 to 8, expanding accessibility and usability for global teams. Additionally, the context window has been expanded from 8k to 16k tokens and latency has been reduced.
Why it matters: This enhancement reduces the need for manual translations, enabling customers to evaluate AI accuracy directly in their preferred languages. By simplifying workflows and enhancing multilingual support, it builds trust in AI systems and Vectara’s platform while empowering teams to address diverse linguistic challenges more effectively.
More information:
December 2024
API v1 Deprecated
Vectara announces the official deprecation of API v1, which will be retired on August 16, 2025. This milestone marks a shift towards leveraging the full capabilities of API v2, offering enhanced functionality, improved developer experience, and streamlined authentication mechanisms. Users are encouraged to migrate their applications to API v2 as soon as possible to ensure uninterrupted service.
Why it matters: REST API v2 improves upon the previous release with standard HTTP response codes, a more intuitive REST URL structure, and new functionality, such as client-side timeouts. Migrating to API v2 allows users to benefit from these improvements while ensuring long-term platform compatibility.
More information:
Update or Replace Document Metadata
Vectara now enables users to update document metadata without reindexing. This capability supports two distinct operations: merging new metadata into existing metadata or replacing the metadata entirely. Both operations are now available through dedicated API endpoints.
Why it matters: Managing metadata is a critical part of ensuring that search and retrieval systems reflect the most up-to-date information. The ability to merge new metadata incrementally enables users to add or adjust specific fields without affecting existing data, while the full replacement operation is ideal for scenarios requiring a clean update. By streamlining metadata updates without reindexing document content, this feature enhances efficiency and ensures smooth document lifecycle management.
New endpoints:
More information:
Querying Table Data
Vectara introduces table querying, a powerful feature designed to help users extract and interact with structured tabular data embedded within documents. By enabling table data extraction during document ingestion, users can leverage Vectara’s advanced APIs to retrieve specific cells, compare semantic values, and gain actionable insights from tables in reports, filings, and other structured documents.
Why it matters: This powerful capability addresses the challenge of retrieving precise information from tables that are often large and complex. With table querying, analysts, researchers, and business users can focus on meaningful insights, reducing the time spent parsing tables manually. Key benefits include quick access to specific data points and streamlined analysis of financial, market, and operational data.
Updated API endpoints:
More information:
Query Observability
Vectara introduces query observability, which enables users to gain deeper insights into query performance and outcomes. Our query observability tool allows developers, business users, and machine learning teams to analyze individual queries by tracking key metrics, inspecting query configurations, and reviewing the execution process. With a detailed breakdown of each query's call stack, users can debug, optimize, and fine-tune their queries for improved relevance and performance.
Why it matters: This feature solves the problem of limited observability into query execution. By surfacing data like query latency, search results, reranking, and generative response times, users can better understand how Vectara’s system performs relative to their business goals.
Updated API endpoints:
More information:
October 2024
New Integrations Section
Vectara introduces a new documentation section highlighting our integrations with various systems in the larger generative AI community, including Airbyte, DataVolo, Flowise, LangChain, LangFlow, LlamaIndex, and Unstructured.io. This section showcases how Vectara's advanced capabilities in document indexing and neural retrieval can enhance AI applications through strategic partnerships.
Why it matters: This update provides developers with an overview of Vectara's community and partner integrations, enabling them to leverage powerful tools and frameworks in conjunction with Vectara's capabilities. These integrations can enable developers to more easily enhance their AI applications, improve search accuracy, and streamline their development process.
More information:
Search Cutoffs and Limits
This feature introduces cutoffs and limits for search results. Cutoffs set a minimum relevance threshold, while limits control the maximum number of returned results after reranking. These can be applied individually or combined across various reranker types.
Why it matters: These controls allow developers to customize reranker inputs, ensuring highly relevant results and optimizing resource usage. By enabling more precise result filtering, application builders have more flexibility for specific use cases, from content categorization to focused data retrieval.
Updated API endpoints:
More information:
Chain Reranker
The Vectara chain reranker lets you apply multiple reranking strategies sequentially, allowing users to combine different reranking strategies and giving you absolute control. This feature enables the application of diverse ranking criteria at each stage of the ranking process, from neural reranking and maximal marginal relevance to custom business logic, all in a customizable sequence.
Why it matters: This unique innovation addresses complex search scenarios that require complex relevance and business rules and enables enterprises to fully customize Vectara's behavior. By allowing the combination of various reranking strategies, it significantly enhances the quality of Retrieval Augmented Generation (RAG) outcomes.
Updated API endpoints:
More information:
Document and Document Part/Vector Count API
You can now retrieve more comprehensive metrics about a corpus, including the number of documents or document parts.
Why it matters: Administrators can now efficiently manage resource allocation and monitor data usage trends. This feature helps ensure that corpus growth stays within allocated quotas and provides insights into document segmentation patterns.
Updated API endpoint:
Retrieve metadata about a corpus
August 2024
UI Enhancement: Custom Prompts in Console
The Vectara Prompt Engine allows users to create customized prompt templates that can reference relevant text and metadata for Retrieval Augmented Generation (RAG) applications.
Why it matters: This feature enables more advanced workflows and customizations for creating context-aware responses, such as answering questions based on previous answers in RFIs or RFPs, drafting support tickets from user feedback, and customizing result formatting. The ability to define roles and provide detailed context in prompts helps guide LLMs to generate more accurate and relevant responses.
More information:
User Defined Function Reranking
Vectara introduces the User Defined Function Reranker, giving enterprises more granular control over search result ordering by defining custom reranking functions using document-level metadata, part-level metadata, or scores generated from the request-level metadata. This flexibility is particularly useful for a wide range of use cases.
Why it matters: This feature allows enterprises to modify scores based on metadata, conditions, and custom logic, in order to craft highly tailored search experiences. This advanced functionality can guide LLMs to prioritize certain information, especially when used with the chain reranker. Use cases can include recency bias for news searches, location bias for local business queries, and e-commerce bias for promotional content.
More information:
July 2024
Mockingbird LLM
Vectara releases Mockingbird, our Large Language Model optimized (LLM) designed for Retrieval Augmented Generation (RAG) scenarios. It offers enhanced accuracy and improved performance in summarizing large datasets, generating structured data, and providing multilingual support.
Why it matters: Mockingbird outperforms leading models in RAG quality, citation accuracy, and structured output precision. It's particularly valuable for enterprises requiring accurate summaries of large data volumes, structured data extraction, and multilingual capabilities. Mockingbird supports critical languages including Arabic, French, Spanish, Portuguese, Italian, German, Chinese, Dutch, Korean, Japanese, and Russian, making it ideal for global applications.
More information:
June 2024
Vectara REST API v2
The Vectara API v2 provides a more RESTful, intuitive structure with simpler authentication, new top-level objects, and better defaults for hybrid search and reranking, making it easier to develop applications with Vectara’s GenAI platform.
Why it matters: This update significantly improves the developer experience, making it easier to integrate Vectara into applications. The standardized error codes and improved defaults reduce development overhead and potential silent errors.
New API endpoint(s):
May 2024
Vectara Multilingual Reranker v1 (Slingshot)
The state-of-the-art Vectara Multilingual Reranker, also known as Slingshot, provides more accurate neural ranking than the initial Boomerang retrieval. By significantly improving the precision of retrieved search results, Slingshot enhances the performance of Retrieval Augmented Generation (RAG) pipelines. It excels in globally distributed, multilingual environments, reducing irrelevant responses and minimizing hallucinations in generative AI applications.
Why it matters: Slingshot significantly enhances the precision of retrieved results, crucial for reducing hallucinations and irrelevant responses in generative AI applications. While computationally more expensive, it offers improved text scoring across a wide range of languages (100+), making it suitable for diverse content as a powerful tool for enterprises.
Deprecated: The reranker_id and rnk_272725719 have been deprecated.
Use reranker_name and Rerank_Multilingual_v1 instead.
More information:
- Vectara Multilingual Reranker
- Unlocking the State-of-the-Art Reranker: Introducing the Vectara Multilingual Reranker_v1
Semantic Conversation History Search
Vectara now allows administrators to search across conversation logs for specific patterns or unresolved queries. This leverages semantic search capabilities to identify gaps in knowledge bases and pinpoint "unknown unknowns" in conversations where users may have asked unexpected or unresolved questions.
Why it matters: With this capability, enterprises can enhance their customer support by analyzing user interactions and improving response accuracy. They can identify unresolved or ambiguous user questions, even if the language is informal or the question does not fit specific patterns.
More information:
Semantic Conversation History Search
Generative Response Styling
Vectara now allows users to format citations in summaries using Markdown or HTML and including document and part level metadata directly in citation links. This feature is useful for enterprises that require formatted, context-rich summaries for integrating generative responses into web-based applications and ensuring citations are clear and appropriately formatted.
Why it matters: By allowing structured citations, Vectara simplifies the integration process for developers who need to embed references directly into user-facing applications without additional parsing logic. This improvement enhances usability for various platforms, including web-based content and internal systems that support HTML or Markdown.
More information: