Know your facts: How Elasticsearch AI Indices let agents skip the reading and keep the answer
A technical walkthrough of precomputing facts into an Elasticsearch AI Index, so agents answer from a single ES|QL query instead of reading whole documents, with fewer tokens and lower latency.
Elasticsearch has native integrations with the industry-leading Gen AI tools and providers. Check out our webinars on going Beyond RAG Basics, or Building Prod-Ready Apps with the Elastic vector database.
To build the best search solutions for your use case, start a free cloud trial or try Elastic on your local machine now.
Pulling whole documents into an agent's context to answer one question is expensive, and the cost compounds with every miss. In this walkthrough, we precompute the facts instead. A Kibana workflow distills each document into a fact-level Knowledge Indicator (KI), stored in an Elasticsearch AI Index and retrieved with a single Elasticsearch Query Language (ES|QL) query. On the same question, an agent answering from KIs reached the same grounded answer using fewer tokens and lower latency than reading raw documents, without loading a single full document into context. These facts are precomputed once and then stored for use by future agents when they encounter similar queries. This is Part 2 of our series on building context with AI indices; Part 1 covered routing agents to the right index.
Managing context depends on good retrieval. Rather than have agents rediscover the same content for every question, burning tokens by retracing similar steps over and over again, Elastic’s agentic AI capabilities enable us to precompute these details and store them in a structured, searchable form, and they let agents load that context directly. We call this precomputed unit of context a Knowledge Indicator.
The default agentic retrieval augmented generation (RAG) pattern does the opposite. It retrieves whole documents and dumps them into the model's context at query time, paying for that retrieval in tokens and latency on every single question. Precomputing the answer as a KI moves that cost out of the hot path and does it once.
How it works: AI Index, Kibana Workflows, and the query-ki skill
Building context through AI indices has three main parts: the AI Index (a special Elasticsearch index where KIs live), Kibana Workflows to create your KIs, and a query-ki skill to help agents directly query KIs using ES|QL:
This blog post is similar to Part 1 in that we’re using the same core building blocks. But in this post, we’re demonstrating a very different use case. Instead of precomputing index metadata, we’re distilling specific facts from our indexed documents that may be used to directly answer agents’ questions without subsequent searches. We've also provided a notebook, if you'd like to create the same KIs yourself, end to end, as you go through these examples.
Prerequisites: Elasticsearch Serverless and an LLM API key
This tutorial assumes you have:
An Elasticsearch Serverless project. You can sign up for a trial if you don't have one.
An API key to access your Elasticsearch project.
An OpenAI-compatible large language model (LLM) API key, to access AI indices via Deep Agents scripts.
Load the BrowseComp-Plus sample corpus into Elasticsearch
First, we’ll need some sources. Sources can be data that already exists in your Elasticsearch indices or external data accessed via connectors or ES|QL data sources.
For this blog, we’ll create an index, browsecomp-plus, to hold our example data, with the following mappings:
{
"browsecomp-plus": {
"mappings": {
"_meta": {
"description": "BrowseComp-Plus corpus: ~100k human-verified web documents (news articles, Wikipedia entries, institutional pages) used as a reasoning-intensive browsing/QA retrieval benchmark. BM25-only index."
},
"properties": {
"docid": {
"type": "keyword",
"meta": {
"description": "Stable corpus document id."
}
},
"text": {
"type": "text",
"meta": {
"description": "Full document text: title, date, and body content."
}
},
"title": {
"type": "text",
"meta": {
"description": "Document title (from the document's front matter)."
}
},
"url": {
"type": "keyword",
"meta": {
"description": "Source URL the document was crawled from."
}
}
}
}
}
}and populate it with a small sample of BrowseComp-Plus data via the _bulk API. You can use the supporting notebook to load a sample of this data in your project.
Create the AI Index that stores your KIs
Just like in Part 1, the first step is to create an AI Index:
PUT ai-index-idx-my-corpusThis is preconfigured with the same required mappings as we listed out in Part 1. We perform hybrid search here using semantic_text out of the box.
How agents retrieve KIs using ES|QL
A KI is a document in the AI Index. What makes KIs useful is retrieval, or querying the AI Index to find the right content. This query is packaged within a small, portable skill that’s harness-agnostic and can be run in any agent harness.
Here’s a sample query-ki skill:
---
name: query-ki
description: >-
Retrieve Knowledge Indicators (precomputed context) from the Elasticsearch AI
Index before answering. Use it to find which index to search (routing profiles)
or to look up precomputed facts without reading source documents. Trigger on any question that depends on specific facts, names, dates, or on choosing a data source.
allowed-tools: esql_query
---
# Retrieving Knowledge Indicators
Knowledge Indicators (KIs) live in Elasticsearch indices named
ai-index-*
.
Retrieve them by calling the
esql_query
tool with the query below. Substitute
the user's question for
<query>
, and
corpus_entry
as the
<ki_type>
for facts.
```esql
FROM ai-index-idx-* METADATA _id, _index, _score
| WHERE type == "<ki_type>"
| FORK
(WHERE MATCH(content, "<query>") OR MATCH(description, "<query>")
| SORT _score DESC | LIMIT 20)
(WHERE MATCH(content.semantic, "<query>") OR MATCH(description.semantic, "<query>")
| SORT _score DESC | LIMIT 20)
| FUSE
| SORT _score DESC
| KEEP title, content, description, tags
| LIMIT 5
```
Ground your answer in what the query returns, and cite the KI titles you used. If
nothing relevant comes back, say so rather than guessing.Save this asskills/query-ki/SKILL.md.
Here’s what this skill is doing:
We’re defining
corpus_entryas our KI use case.We’re performing a hybrid ES|QL search on our AI indices, filtering by the appropriate
type, using reciprocal rank fusion (RRF) as the default method to fuse results.The KI results will directly ground the agent’s answer when determining what facts are relevant to the users’ query.
When we say that AI indices and KIs are harness-agnostic, it’s because the skill is just instructions plus a query. It will work in Elastic Agent Builder, a Kibana workflow agent, Claude Code, or any other harness. We’ll be using Deep Agents for examples of how to query it outside the Kibana ecosystem. Since an AI Index is, at its core, an Elasticsearch index, you can also explore your data directly.
Precompute facts as KIs for agentic RAG
In this example, we extract actual facts so agents can retrieve an answer without consuming a full document. We generate one fact-based KI per selected document, though the actual number and structure of KIs you generate are completely customizable.
We'll use a sample of the BrowseComp-Plus corpus, indexed into a browsecomp-plus index, with docid, url, title, and text fields.
Baseline: Retrieving whole documents with RRF
As a baseline, here's a simple RRF query:
POST /_query?format=txt
{
"query": """
FROM browsecomp-plus METADATA _score, _id, _index
| FORK
(WHERE match(title, "What was the actress who played Torvi from Vikings also known for?") | SORT _score DESC | LIMIT 100)
(WHERE match(text, "What was the actress who played Torvi from Vikings also known for?") | SORT _score DESC | LIMIT 100)
| FUSE // uses RRF by default
| SORT _score DESC
| KEEP _id, title, text
| LIMIT 10
"""
}This drops several hundred words of raw body text into the model's context. It may work, but it's expensive, and the cost compounds with every miss.
Build the Kibana workflow
The workflow below reads a batch of documents with a single ES|QL query and writes one fact-level KI per document into the AI Index. Each iteration runs two steps: generate_ki distills a raw document into a structured KI, and sink_ki writes it to the AI Index keyed on docid so reruns are idempotent.
Copy and paste the following YAML into the Elastic Workflows editor:
version: '1'
name: browsecomp-plus-doc-ki
description: Query the BrowseComp-Plus corpus with ES|QL, generate a KI per doc with an AI agent, and bulk-write each into the AI Index as a corpus_entry.
enabled: true
tags:
- precomputed-context
- browsecomp-plus
triggers:
- type: manual
steps:
- name: query_corpus
type: elasticsearch.esql.query
with:
# WHERE drops empty bodies and restricts to the curated KI_DOCIDS -- the
# specific documents this example's question depends on -- so the workflow
# generates only a handful of KIs instead of one per corpus document.
# SUBSTRING keeps the prompt bounded (a full body would blow the context window).
# Column order drives the foreach.item[N] indices:
# item[0]=docid item[1]=title item[2]=url item[3]=text
query: >
FROM browsecomp-plus
| WHERE text IS NOT NULL AND docid IN ("11589", "50639", "64501", "41758", "57766", "84983", "82008")
| KEEP docid, title, url, text
| EVAL text = SUBSTRING(text, 1, 12000)
- name: loop_corpus_docs
type: foreach
foreach: '{{ steps.query_corpus.output.values }}'
steps:
# Turn the raw doc into a retrieval-optimized Knowledge Indicator.
- name: generate_ki
type: ai.agent
timeout: 300s
with:
message: >
You are a knowledge engineer building a Knowledge Indicator (KI)
for an enterprise document-retrieval corpus. A KI is a compact,
high-signal record that a hybrid (BM25 + semantic) search engine
and an AI agent use to FIND and JUDGE the source document without
reading it in full.
Read the document below and extract a faithful, richly structured KI.
Follow these rules strictly:
- Be 100% grounded: never state anything not supported by the text.
- Prefer concrete, named specifics (people, organizations, products,
dates, places, figures) over vague phrasing.
- Write for retrieval, not prose flourish. No marketing language.
- If a field cannot be determined from the text, return an empty
string or empty array rather than guessing.
Document ID: {{ foreach.item[0] }}
Original Title: {{ foreach.item[1] }}
Source URL: {{ foreach.item[2] }}
Document Body:
{{ foreach.item[3] }}
schema:
type: object
properties:
title:
type: string
description: A concise, specific, human-readable title (<= 12 words).
summary:
type: string
description: A dense 3-5 sentence factual summary capturing the document's main claims, named entities, and conclusions. PRIMARY semantic search surface.
answers_questions:
type: array
items:
type: string
description: 2-5 natural-language questions this document can authoritatively answer.
key_entities:
type: array
items:
type: string
description: 3-10 salient named entities (people, organizations, products, places, dates) explicitly mentioned in the text.
topics:
type: array
items:
type: string
description: 3-8 short topic/category labels.
tagline:
type: string
description: A single ultra-short phrase (<= 6 words) as a quick-reference label.
required:
- title
- summary
- answers_questions
- key_entities
- topics
# Direct bulk write to the AI Index. The explicit
index
action row sets
# _id = docid so re-runs upsert in place (idempotent).
index:
in
with
# supplies the default target index for the bulk request.
- name: sink_ki
type: elasticsearch.bulk
with:
index: ai-index-idx-my-corpus
operations:
- index:
_id: '{{ foreach.item[0] }}'
- '@timestamp': '{{ execution.startedAt | date: "%Y-%m-%dT%H:%M:%S.%LZ" }}'
type: corpus_entry
title: '{{ foreach.item[1] | default: steps.generate_ki.output.structured_output.title }}'
tags:
- browsecomp-plus
references:
uri: '{{ foreach.item[2] }}'
attributes:
docid: '{{ foreach.item[0] }}'
url: '{{ foreach.item[2] }}'
source_index: browsecomp-plus
tagline: '{{ steps.generate_ki.output.structured_output.tagline }}'
topics: '{{ steps.generate_ki.output.structured_output.topics | json }}'
answers_questions: '{{ steps.generate_ki.output.structured_output.answers_questions | json }}'
key_entities: '{{ steps.generate_ki.output.structured_output.key_entities | json }}'
content: >
=== SOURCE / PROVENANCE ===
Backing Elasticsearch index: browsecomp-plus
Document ID (docid): {{ foreach.item[0] }}
Source URL: {{ foreach.item[2] }}
Retrieve the full original document with ES|QL:
FROM browsecomp-plus | WHERE docid == "{{ foreach.item[0] }}"
=== KNOWLEDGE INDICATOR ===
{{ steps.generate_ki.output.structured_output.summary }}
Questions this document answers: {{ steps.generate_ki.output.structured_output.answers_questions | join: " | " }}
Key entities: {{ steps.generate_ki.output.structured_output.key_entities | join: ", " }}
description: >
{{ steps.generate_ki.output.structured_output.tagline }}.
Topics: {{ steps.generate_ki.output.structured_output.topics | join: ", " }}.
Entities: {{ steps.generate_ki.output.structured_output.key_entities | join: ", " }}.Here’s what this workflow is doing:
query_corpusruns an ES|QL query against thebrowsecomp-plusindex, applying some rules, like dropping documents with empty bodies and trimming each body to 12,000 chars so the agent prompt stays inside the context window.Note: In this example, we’re cherry-picking some concrete KI IDs, because generating KIs for every document in the index would take a long time, and we want this exercise to be short for those following along.
loop_corpus_docsiterates over every returned document, running the following two steps per document:generate_kireads the document and calls an LLM to emit a strictly grounded, structured KI.sink_kibulk-writes each KI into the AI Index (ai-index-idx-my-corpus) as a KI of typecorpus_entry. It forces_idto be the same as the document’sdocidso rerunning the workflow is idempotent.
To summarize, this workflow turns each raw corpus document into a compact, searchable metadata record that agents can find and judge without reading the full source into the context window.
This workflow is used for example purposes, and the same foreach caveat as in Part 1 applies. For scale, use workflow.executeAsync or native parallel support. The cheat sheet is useful for optimizing Workflows. There could also be cost and efficiency gains in production by using ai.prompt or by choosing different models with which to create KIs.
Inspect the KIs in your AI Index
Once the workflow runs, you can query the AI Index to browse what was written:
FROM ai-index-idx-*
| WHERE type == "corpus_entry"
| KEEP title, description, attributes, tags
| LIMIT 25Here’s an example of what one of the KI documents looks like:
{
"_index": "ai-index-idx-my-corpus",
"_id": "57766",
"_version": 1,
"_seq_no": 0,
"_primary_term": 1,
"found": true,
"_source": {
"@timestamp": "2026-08-05T20:35:39.034Z",
"type": "corpus_entry",
"title": "Vikings (TV series) - Wikipedia",
"tags": [
"browsecomp-plus"
],
"references": {
"uri": "https://en.wikipedia.org/wiki/Vikings_%28TV_series%29"
},
"attributes": {
"docid": "57766",
"url": "https://en.wikipedia.org/wiki/Vikings_%28TV_series%29",
"source_index": "browsecomp-plus",
"tagline": "Ragnar Lothbrok's rise and legacy",
"topics": """["Historical drama television","Viking Age","Norse mythology and sagas","Canadian-Irish co-production","Television cast and production","Medieval Scandinavia"]""",
"answers_questions": """["When did the Vikings TV series premiere and on which network?","Who created and wrote the Vikings TV series?","Where was the Vikings TV series filmed?","Who are the main cast members of Vikings?","What historical and literary sources inspired the Vikings TV series?"]""",
"key_entities": """["Michael Hirst","Travis Fimmel","Katheryn Winnick","History Channel","Amazon Prime Video","Ashford Studios","County Wicklow, Ireland","Vikings: Valhalla","Ragnar Lodbrok","Wardruna"]"""
},
"content": """=== SOURCE / PROVENANCE === Backing Elasticsearch index: browsecomp-plus Document ID (docid): 57766 Source URL: https://en.wikipedia.org/wiki/Vikings_%28TV_series%29 Retrieve the full original document with ES|QL: FROM browsecomp-plus | WHERE docid == "57766" === KNOWLEDGE INDICATOR === Vikings is a historical drama television series created and written by Michael Hirst, co-produced between Canada and Ireland, that premiered on the History Channel on March 3, 2013, and concluded on March 3, 2021, after 6 seasons and 89 episodes. The series is inspired by the sagas of legendary Norse hero Ragnar Lodbrok — drawing on 13th-century texts Ragnars saga Loðbrókar and Ragnarssona þáttr, as well as Saxo Grammaticus' Gesta Danorum — and follows Ragnar's rise from farmer to Scandinavian king, then the exploits of his sons across England, Scandinavia, Kievan Rus', the Mediterranean, and North America. Principal cast includes Travis Fimmel as Ragnar Lothbrok, Katheryn Winnick as Lagertha, Gustaf Skarsgård as Floki, and Alexander Ludwig as Bjorn Ironside, among many others. The series was filmed entirely in Ireland at Ashford Studios and County Wicklow, with additional location shoots in Iceland, Morocco, Norway, and Canada; the first season budget was US$40 million. A sequel series, Vikings: Valhalla, premiered on Netflix on February 25, 2022. Questions this document answers: When did the Vikings TV series premiere and on which network? | Who created and wrote the Vikings TV series? | Where was the Vikings TV series filmed? | Who are the main cast members of Vikings? | What historical and literary sources inspired the Vikings TV series? Key entities: Michael Hirst, Travis Fimmel, Katheryn Winnick, History Channel, Amazon Prime Video, Ashford Studios, County Wicklow, Ireland, Vikings: Valhalla, Ragnar Lodbrok, Wardruna
""",
"description": """Ragnar Lothbrok's rise and legacy. Topics: Historical drama television, Viking Age, Norse mythology and sagas, Canadian-Irish co-production, Television cast and production, Medieval Scandinavia. Entities: Michael Hirst, Travis Fimmel, Katheryn Winnick, History Channel, Amazon Prime Video, Ashford Studios, County Wicklow, Ireland, Vikings: Valhalla, Ragnar Lodbrok, Wardruna.
"""
}
}Query KIs from LangChain Deep Agents
We’ll use LangChain Deep Agents with an OpenAI-compatible key to show that AI indices and KIs will work with any agent harness, inside and outside of Kibana’s Agent Builder ecosystem.
First, let’s create facts_baseline_agent.py to measure our baseline before applying KIs:
# Example question: What was the actress who played Torvi from Vikings also known for?
import os
import sys
import time
from elasticsearch import Elasticsearch
from langchain_core.messages import AIMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from deepagents import create_deep_agent
if len(sys.argv) < 2:
sys.exit(f'Usage: python {sys.argv[0]} "your question"')
es = Elasticsearch(os.environ["ES_URL"], api_key=os.environ["ES_API_KEY"])
@tool
def esql_query(query: str) -> list[dict] | str:
"""Execute an ES|QL query against Elasticsearch and return the matching rows.
Args:
query: A complete ES|QL query string, e.g. 'FROM browsecomp-plus | LIMIT 5'.
Full-text search syntax: WHERE MATCH(field, "value") — not field MATCH "value".
"""
try:
resp = es.esql.query(query=query, format="json")
cols = [c["name"] for c in resp["columns"]]
return [dict(zip(cols, row)) for row in resp["values"]]
except Exception as e:
return f"ES|QL error: {e}"
@tool
def get_mapping(index: str) -> dict:
"""Return the field mapping for an Elasticsearch index or pattern."""
return es.indices.get_mapping(index=index).body
baseline_agent = create_deep_agent(
model=ChatOpenAI( # any OpenAI-compatible endpoint; configure via LLM_* env vars
base_url=os.environ.get("LLM_BASE_URL", "https://openrouter.ai/api/v1"),
model=os.environ.get("LLM_MODEL", "anthropic/claude-sonnet-4.5"),
api_key=os.environ["LLM_API_KEY"],
),
tools=[esql_query, get_mapping], # no query-ki skill
system_prompt=(
"You are a research assistant answering questions about a document corpus "
"stored in the Elasticsearch index
browsecomp-plus
(fields: docid, url, "
"title, text). You have NOT memorized the corpus. Answer by querying the raw "
"index directly with ES|QL via the esql_query tool. "
"Full-text search syntax: WHERE MATCH(field, \"value\") — never use field MATCH \"value\". "
"Use get_mapping if you are unsure of field names. Ground your answer strictly "
"in the rows returned, and cite the docid or url you used."
),
)
start = time.perf_counter()
result = baseline_agent.invoke(
{
"messages": [
{
"role": "user",
"content": sys.argv[1],
}
]
}
)
latency = time.perf_counter() - start
print("\n--- Tool calls ---")
for m in result["messages"]:
if isinstance(m, AIMessage) and m.tool_calls:
for tc in m.tool_calls:
print(f" [{tc['name']}] {str(tc['args'])[:120]}")
total = sum(
len(m.tool_calls)
for m in result["messages"]
if isinstance(m, AIMessage) and m.tool_calls
)
print(f"Total: {total}\n")
print("--- Usage ---")
input_tokens = sum(
(m.usage_metadata or {}).get("input_tokens", 0)
for m in result["messages"]
if isinstance(m, AIMessage) and m.usage_metadata
)
output_tokens = sum(
(m.usage_metadata or {}).get("output_tokens", 0)
for m in result["messages"]
if isinstance(m, AIMessage) and m.usage_metadata
)
print(f"Tokens: {input_tokens + output_tokens} (input {input_tokens}, output {output_tokens})")
print(f"Latency: {latency:.2f}s\n")
print("--- Answer ---")
print(result["messages"][-1].content)When I ran this baseline query, What was the actress who played Torvi from Vikings also known for?, it output the following:
% python facts_baseline_agent.py "What was the actress who played Torvi from Vikings also known for?"
--- Tool calls ---
[esql_query] {'query': 'FROM browsecomp-plus | WHERE MATCH(text, "Torvi Vikings actress") | LIMIT 10'}
[esql_query] {'query': 'FROM browsecomp-plus | WHERE MATCH(text, "Georgia Hirst") | LIMIT 10'}
[read_file] {'file_path': '/large_tool_results/toolu_bdrk_01SVEwHdtc9uE1zdfgCwchb5', 'offset': 0, 'limit': 50}
[esql_query] {'query': 'FROM browsecomp-plus | WHERE MATCH(text, "Torvi Vikings TV") | LIMIT 10'}
[esql_query] {'query': 'FROM browsecomp-plus | WHERE MATCH(text, "Vikings series cast actress") | LIMIT 10'}
[esql_query] {'query': 'FROM browsecomp-plus | WHERE MATCH(text, "Michael Hirst Vikings") | LIMIT 10'}
[esql_query] {'query': 'FROM browsecomp-plus | WHERE MATCH(text, "Torvi") | LIMIT 20'}
[read_file] {'file_path': '/large_tool_results/toolu_bdrk_01PS3ryzML5BstqMXnV4c65N', 'offset': 0, 'limit': 100}
Total: 8
--- Usage ---
Tokens: 386187 (input 384940, output 1247)
Latency: 44.86s
--- Answer ---
Perfect! I found the information. Based on the document from docid 11589 (Georgia Hirst's Wikipedia page), I now have the answer to the question.
**Georgia Hirst**, the actress who played Torvi in the History Channel series Vikings (2014-2020), is also known for:
1. **Her role as Becky in the zombie horror movie "Ravers" (2018)** - This film had its world premiere at the 2018 London FrightFest Film Festival.
2. **Being the daughter of Michael Hirst**, the creator and writer of Vikings. This is a notable connection that's frequently mentioned about her.
3. **Her role in the short film "Dungeness" (2018)**, directed by Stephen Gates, where she was the sole actor.
4. **Her role as Grace in the interactive rom-com "Five Dates" (2020)**.
5. **Her advocacy work** - In 2017, she made an appearance on Sky News urging young women to get smear tests after being diagnosed with precancerous cells at age 22.
6. **Her philanthropy** - She joined The Celebs in 2021 to record a cover of The Beatles' "Let It Be" in support of the Mind charity.
So while she's primarily known for her role as Torvi in Vikings (where she appeared in 63 episodes across seasons 2-6), she's also recognized for her work in horror films like "Ravers," her health advocacy, and being part of the Hirst family that created the show.(Note: Deep Agents automatically adds the read_file tool to handle paginated tool results, which is why it shows up in the output.)
Next, let’s create an agent that knows how to use our query-ki skill, facts_ki_agent.py:
# Example question: What was the actress who played Torvi from Vikings also known for?
import os
import sys
import time
from elasticsearch import Elasticsearch
from langchain_core.messages import AIMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from deepagents import create_deep_agent
from deepagents.backends.filesystem import FilesystemBackend
if len(sys.argv) < 2:
sys.exit(f'Usage: python {sys.argv[0]} "your question"')
es = Elasticsearch(os.environ["ES_URL"], api_key=os.environ["ES_API_KEY"])
@tool
def esql_query(query: str) -> list[dict] | str:
"""Execute an ES|QL query against Elasticsearch and return the matching rows.
Args:
query: A complete ES|QL query string, e.g. 'FROM ai-index-idx-* | LIMIT 5'.
"""
try:
resp = es.esql.query(query=query, format="json")
cols = [c["name"] for c in resp["columns"]]
return [dict(zip(cols, row)) for row in resp["values"]]
except Exception as e:
return f"ES|QL error: {e}"
# FilesystemBackend loads skills from disk, relative to root_dir.
backend = FilesystemBackend(root_dir=".", virtual_mode=False)
agent = create_deep_agent(
model=ChatOpenAI( # any OpenAI-compatible endpoint; configure via LLM_* env vars
base_url=os.environ.get("LLM_BASE_URL", "https://openrouter.ai/api/v1"),
model=os.environ.get("LLM_MODEL", "anthropic/claude-sonnet-4.5"),
api_key=os.environ["LLM_API_KEY"],
),
tools=[esql_query],
skills=["skills"],
backend=backend,
system_prompt=(
"You are a research assistant answering questions about a document corpus. "
"You have NOT memorized the corpus. When a question depends on specific facts, "
"names, dates, or events, use the query-ki skill to retrieve Knowledge "
"Indicators before answering. Ground your answer strictly in what it returns, "
"and cite the KI titles you used."
),
)
start = time.perf_counter()
result = agent.invoke(
{
"messages": [
{
"role": "user",
"content": sys.argv[1],
}
]
}
)
latency = time.perf_counter() - start
print("\n--- Tool calls ---")
for m in result["messages"]:
if isinstance(m, AIMessage) and m.tool_calls:
for tc in m.tool_calls:
print(f" [{tc['name']}] {str(tc['args'])[:120]}")
total = sum(
len(m.tool_calls)
for m in result["messages"]
if isinstance(m, AIMessage) and m.tool_calls
)
print(f"Total: {total}\n")
print("--- Usage ---")
input_tokens = sum(
(m.usage_metadata or {}).get("input_tokens", 0)
for m in result["messages"]
if isinstance(m, AIMessage) and m.usage_metadata
)
output_tokens = sum(
(m.usage_metadata or {}).get("output_tokens", 0)
for m in result["messages"]
if isinstance(m, AIMessage) and m.usage_metadata
)
print(f"Tokens: {input_tokens + output_tokens} (input {input_tokens}, output {output_tokens})")
print(f"Latency: {latency:.2f}s\n")
print("--- Answer ---")
print(result["messages"][-1].content)This agent will query the KI indices to generate the answer, rather than pulling every document into context.
When I ran these results against the same query, here was the output:
% python facts_ki_agent.py "What was the actress who played Torvi from Vikings also known for?"
--- Tool calls ---
[read_file] {'file_path': './query-ki/SKILL.md', 'limit': 1000}
[esql_query] {'query': 'FROM ai-index-idx-* METADATA _id, _index, _score\n| WHERE type == "corpus_entry"\n| FORK\n (WHERE MATCH(co
Total: 2
--- Usage ---
Tokens: 27625 (input 27037, output 588)
Latency: 15.22s
--- Answer ---
Based on the retrieved information, **Georgia Hirst** played Torvi in Vikings. She is also known for:
1. **Ravers (2018)** - A zombie horror film where she played the character Becky. This was her debut film and premiered at the London FrightFest Film Festival.
2. **Being the daughter of Michael Hirst** - The creator and writer of Vikings itself, making her connection to the show a notable family affair. Her older half-sister Maude Hirst also appeared in Vikings as Helga.
3. **Cervical cancer awareness advocacy** - She has publicly advocated for cervical cancer screening after being diagnosed with precancerous cells at age 22 and successfully recovering through treatment.
4. **Charity work** - In 2021, she participated in a celebrity cover of The Beatles' "Let It Be" in support of the Mind charity (a mental health organization), alongside Anne Hegerty, Ivan Kaye, Eunice Olumide, and Shona McGarty.
**Sources cited:** "Georgia Hirst" and "Georgia Hirst - Wikipedia" Knowledge Indicators from the AI Index.How much can precomputing facts reduce agent token usage?
Both agents had similar conclusions, but they took far different paths to get there:
The same question and the same grounded answer result in 93% fewer tokens and two tool calls instead of eight, when answering from KIs.
| Baseline (No AI Index) | With AI Index |
Total tool calls | 8 | 2 |
| 2 | 1 |
| 6, all against the | 1, from |
Tokens consumed | 386,187 | 27,625 |
Latency | 44.86s | 15.22s |
Answer | Grounded, correct | Grounded, correct |
Exact tool call counts, latency, and answers will vary between runs and using different agents.
Both agents produced solid, grounded answers. The difference is cost. Querying KIs from the AI Index cut token use by 93% and cut latency by roughly two thirds. Here’s how both paths went, side by side:
That was in-depth, but it shows what AI indices and Workflows do together: the same answer, at a fraction of the tokens.
Build precomputed context in Elasticsearch Serverless
This walkthrough shows how to generate more sophisticated KIs based on documented facts and query them for knowledge retrieval use cases using Elasticsearch primitives.
Managing context is critical in agentic search systems. And at its core, context is a retrieval problem. AI indices help you manage context within the Elastic Stack. Try it out in Serverless, and let us know what you think in our Discuss forums or the #stack-kibana channel in our Community Slack.
We’d also love to hear from you about what use cases you’d like to solve using AI indices.
