repository·main·Indexed 22 days ago
https://github.com/embeddedllm/jamaibaseAn open-source RAG backend platform that combines embedded databases (SQLite and LanceDB) with managed LLM orchestration. It provides a declarative way to build AI-powered applications via a REST API or spreadsheet-like UI, featuring Generative Tables (Action, Knowledge, and Chat tables) for chaining LLM reasoning and implementing Retrieval Augmented Generation.
JamAI Base uses different table types to handle various AI and data workflows:
A Python Column allows you to generate or transform cell values using custom Python code. It operates on a row-by-row basis within a Generative Table.
row.row dictionary using the exact name of the Python Column.row using upstream column names.row["Your Python Column Name"].Tip: Use try/except blocks and provide fallback values to ensure stability.
# Read from upstream columns
value_a = row["Input Column A"]
value_b = row["Input Column B"]
# Do some processing
result = f"{value_a} - processed with {value_b}"
# Write to this column
row["Python Column Name"] = resultAn LLM Column in a Generative Table allows you to synthesize outputs using a Large Language Model (LLM). It functions by combining a System Prompt, a Prompt, and optional Retrieval Augmented Generation (RAG) settings to generate a value for each cell in the column.
The LLM Column lifecycle:
When sending messages to the JamAI Chat API, a user message can be composed of multiple media types. A single message may include:
Additionally, users can request Retrieval-Augmented Generation (RAG) to allow the model to retrieve context from a connected Knowledge Table. When RAG is active, the assistant's response will include RAG references.
JamAI Base provides built-in RAG (Retrieval-Augmented Generation) features so you don't have to build the pipeline manually. Key capabilities include:
JamAI Base provides three types of Generative Tables designed for different LLM workflows:
gen_config to trigger LLM generation based on input columns.You can dynamically inject values from other columns into your image prompt using column references. At runtime, the placeholder is replaced with the current row's value.
Syntax:
${Column Name} directly into the prompt editor.Example Prompt:
A cinematic portrait of ${Subject} in a neon city
A cinematic portrait of ${Subject} in a neon cityRAG allows you to ground LLM outputs in external knowledge stored in a Knowledge Table. When enabled, the LLM Column follows these steps:
k to control how many top references are injected into the prompt.[@ref0; @ref1]) to show which references support the generated text.The final prompt sent to the LLM includes your System Prompt, Prompt, and the injected references.
JamAI Base follows Semantic Versioning.
The SDK is currently in the v0.x.x phase. During this stage, the public API is considered unstable, and breaking changes may occur at any time without notice.
Once the SDK reaches version 1.x.x, version increments will follow these rules:
1.x.x): Incremented for backwards-incompatible updates to the Cloud service/backend that require changes to the SDK.x.y.x): Incremented for backwards-compatible feature updates or enhancements to the SDK libraries.x.x.z): Incremented for backwards-compatible bug fixes.Enabling Multi-turn Chat allows the LLM to use data from previous rows as conversation history, enabling context-aware interactions across the table.
Behavior:
Example Workflow:
Query is What is 2+2? $\rightarrow$ Output is 4.Query is Add 3 $\rightarrow$ Because Multi-turn Chat is enabled, the LLM understands the context and returns 7.To implement Retrieval Augmented Generation (RAG):
jamai.table.embed_file(file_path, table_id). This processes the file and adds it to the Knowledge Table.rag_params in the LLMGenConfig of your generative column.table_id: The ID of the Knowledge Table to query.k: The number of relevant chunks to retrieve.t.CellReferencesResponse objects. These contain the chunks retrieved from the Knowledge Table, allowing you to see the grounding context.# 1. Embed a file into a Knowledge Table
response = jamai.table.embed_file("path/to/text.txt", "knowledge-simple")
# 2. Create Action Table with RAG configuration
table = jamai.table.create_action_table(
t.ActionTableSchemaCreate(
id="action-rag",
cols=[
t.ColumnSchemaCreate(id="question", dtype="str"),
t.ColumnSchemaCreate(
id="answer",
dtype="str",
gen_config=t.LLMGenConfig(
model="openai/gpt-4o-mini",
prompt="${question}",
rag_params=t.RAGParams(
table_id="knowledge-simple",
k=2,
),
),
),
],
)
)
# 3. Query with streaming to catch references
completion = jamai.table.add_table_rows(
"action",
t.MultiRowAddRequest(table_id="action-rag", data=[dict(question="...")], stream=True),
)
for chunk in completion:
if isinstance(chunk, t.CellReferencesResponse):
print("Retrieved chunks:", chunk.chunks)
elif chunk.output_column_name == "answer":
print(chunk.text, end="", flush=True)