repository·master·Indexed 11 days ago
https://github.com/neuml/txtaiAn all-in-one AI framework for semantic search, LLM orchestration, and language model workflows. Built on an embeddings database, it supports vector search, RAG, autonomous agents via smolagents, and multimodal indexing for text, audio, images, and video. It provides Web and Model Context Protocol (MCP) APIs with bindings for JavaScript, Java, Rust, and Go.
txtai is an all-in-one AI framework designed for semantic search, LLM orchestration, and language model workflows. Its core is an embeddings database that combines vector indexes (sparse and dense), graph networks, and relational databases.
Key Features:
The txtai API is accessible through several official language bindings and standard protocols:
Language Bindings:
Compatibility:
The Tokenizer pipeline splits text into individual tokens, which is primarily used for keyword or term indexing.
Important Note: This pipeline is intended for keyword indexing and is not designed for use with Transformers-based models, as those models use their own specialized tokenizers.
from txtai.pipeline import Tokenizer
tokenizer = Tokenizer()
result = tokenizer("text to tokenize")txtai provides a comprehensive suite of AI capabilities:
Enabling a graph network adds a semantic graph at index time. txtai uses vector embeddings to automatically create relationships between nodes, but you can also specify them manually.
You can define relationships during the index call in two ways:
id and a relationship type (e.g., MEMBER_OF).Once indexed, you can interact with the graph using:
embeddings.graph.topics: Returns a mapping of discovered topics to associated IDs.embeddings.graph.centrality(): Returns the most central nodes in the index.Graphs are persisted alongside the embeddings index during save and load operations.
# Manual relationships by id
embeddings.index([{"id": "0", "text": "...", "relationships": ["2"]}])
# Manual relationships with additional edge attributes
embeddings.index([{"id": "0", "text": "...", "relationships": [
{"id": "2", "type": "MEMBER_OF"}
]}])For language-generation and language-modeling tasks, the merge parameter controls how text is packed into chunks to improve training efficiency by reducing padding.
concat (default): Text is split into chunks up to maxlength. Data can be split across multiple chunks. This maximizes efficiency and is recommended for general masked language modeling.pack: Text is split into chunks up to maxlength. Data is guaranteed to stay within the same chunk, though chunks may be smaller than maxlength. This is recommended for instruction/prompt fine-tuning to ensure complex logic isn't split.None: Disables merging entirely.Unlike standard Retrieval Augmented Generation (RAG) which performs a single vector search, Agentic RAG uses an agent to perform multiple iterations and potentially query multiple databases to reach a conclusion. This is useful for aggregating information from diverse sources to build complex reports.
To implement this, pass a detailed prompt (instruction) to the Agent instance, instructing it on how to use its available tools to research and format the output.
researcher_prompt = """
You're an expert researcher looking to write a paper on {topic}.
Search for websites, scientific papers and Wikipedia related to the topic.
Write a report with summaries and references (with hyperlinks).
Write the text as Markdown.
"""
# The agent will use its tools to fulfill the multi-step research instruction
agent(researcher_prompt.format(topic="alien life"))In txtai, agents can be used as tools for other agents. This allows you to build Agent Teams, where a primary agent delegates tasks to specialized sub-agents. Each sub-agent has its own reasoning engine and toolset.
To create an agent team:
websearcher agent or a wikiman agent).tools list using a dictionary with a target key pointing to the sub-agent instance.Sub-agent tool dictionary format:
name: The name the primary agent uses to refer to the tool.description: Instructions for the primary agent on when to use this sub-agent.target: The actual Agent instance to be invoked.from txtai import Agent, LLM
llm = LLM("Qwen/Qwen3-4B-Instruct-2507")
# Define specialized sub-agents
websearcher = Agent(model=llm, tools=["websearch"])
wikiman = Agent(
model=llm,
tools=[{
"name": "wikipedia",
"description": "Searches a Wikipedia database",
"provider": "huggingface-hub",
"container": "neuml/txtai-wikipedia"
}]
)
# Define the primary agent that uses the sub-agents as tools
agent = Agent(
model=llm,
tools=[
{
"name": "wikiman",
"description": "Wikipedia has all the answers, I search Wikipedia and answer questions",
"target": wikiman
},
{
"name": "websearcher",
"description": "I run web searches, there is no answer a web search can't solve!",
"target": websearcher
}
],
max_steps=10
)
agent("Research fundamental concepts about Signal Processing and build a comprehensive report.")To add custom logic that executes with every request, use Dependencies. Dependencies function as middleware and are ideal for implementing custom authorization steps, authentication methods, or other request-processing logic that should run before the main application logic.
See the [API Authorization and Authentication](https://github.com/neuml/txtai/blob/master/examples/54_API_Authorization_and_Authentication.ipynb) notebook for a detailed implementation example.If content storage is enabled, you can use SQL to combine similarity searches with structured filters. The similar clause is the bridge between the similarity index and the relational database.
Syntax:
similar("query", "number of candidates", "index", "weights")
| Argument | Description |
|---|---|
query | Natural language query string |
number of candidates | Number of candidate results to return. Should be larger than the desired LIMIT to account for filters. Defaults to query limit for single filters, or 10x limit for multiple filters. |
index | Target subindex name (if subindexes are enabled) |
weights | Hybrid score weights (for sparse/dense indexes) |
Example:
SELECT id, text, score FROM txtai WHERE similar('feel good story')txtai provides orchestration for Large Language Models (LLMs), including autonomous agents, Retrieval Augmented Generation (RAG), and complex task chains.
Agents in txtai connect embeddings, pipelines, and workflows to solve complex problems autonomously. They are built on top of the smolagents framework and support:
agents.md and skill.md specifications.RAG reduces LLM hallucinations by providing a knowledge base as context (e.g., "chat with your data"). txtai supports: