LLMs are stateless. Every API call starts cold. That works for one-shot answers, and fails for agents that must remember preferences, past decisions, and lessons across sessions.

Weaviate Engram is a managed memory service built on Weaviate for exactly that problem. You send raw conversations or events. Engram extracts structured memories, reconciles them with what it already knows, and stores them for semantic search. Your agent stays fast because memory work runs asynchronously, while recall stays precise because retrieval is backed by Weaviate’s vector index.

This guide shows how to wire Engram into a real agent loop.

Why agents need Engram (not just a bigger context window)

Stuffing full chat history into every request looks simple. It does not scale.

• Long context raises cost and latency on every turn.
• Models still get lost in the middle.
• Raw transcripts are noisy, contradictory, and outdated.
• Multi-agent workflows split one task across multiple windows, so “one transcript” is not enough.

Engram’s model is different: actively maintain memories. Extract facts. Deduplicate. Update when preferences change. Retrieve only what is relevant for the next decision.

What Engram is

Engram is a memory server for LLM agents and apps. It exposes a REST API (https://api.engram.weaviate.io) and a Python SDK (weaviate-engram).

Core capabilities:

Core concepts (keep these straight)

• Memories — discrete facts, embedded as vectors for search
• Topics — categories that guide extraction (e.g. UserKnowledge, experience)
• Groups — bundles of topics + a pipeline for one use case (often default)
• Scopes — who a memory belongs to:
• project-wide (shared learning)
• user-scoped (hard isolation via multi-tenancy)
• property-scoped (e.g. one summary per conversation_id)
• Pipelines — async graphs that extract, reconcile, and commit

Templates like Personalization get you started without designing pipelines from scratch.

Setup

1. Create an Engram project in Weaviate Cloud (Personalization template is a good start).
2. Create an API key and save it immediately.
3. Install the client:

pip install weaviate-engram anthropic

# or: uv add weaviate-engram

export ENGRAM_API_KEY=”eng_…”

export ANTHROPIC_API_KEY=”sk-ant-…”

import os

from engram import EngramClient

client = EngramClient(api_key=os.environ[“ENGRAM_API_KEY”])

The agent memory loop

A practical agent loop with Engram has three steps each turn:

1. Recall — search memories for the current user message
2. Act — call the LLM with recent turns + recalled context
3. Remember — fire-and-forget the new exchange into Engram

1) Store conversations (async)

run = client.memories.add(

[

{“role”: “user”, “content”: “I just moved to Berlin and prefer specialty coffee, not chains.”},

{“role”: “assistant”, “content”: “Got it — I’ll keep specialty spots in Berlin in mind.”},

],

user_id=”alice”,

group=”default”,

)

print(run.run_id, run.status)

Engram returns a run_id immediately. The pipeline:

1. Extract — pull topic-matching facts
2. Transform — dedupe / merge with existing memories
3. Commit — persist to Weaviate

You can poll with client.runs.wait(run.run_id) when you need consistency before the next search. In most chat UIs, fire-and-forget is fine because the latest turn is already in short-term context.

Other input types:

• String — app events (“User viewed pricing page”)
• Pre-extracted — agent decides what to remember via tool calls

2) Recall before the model responds

from engram import HybridRetrieval

results = client.memories.search(

query=”What kind of coffee does the user like?”,

user_id=”alice”,

group=”default”,

retrieval_config=HybridRetrieval(limit=5),

)

memory_context = “\n”.join(f”- {m.content}” for m in results)

Retrieval options:

Minimal memory-enabled agent

import os

import anthropic

from engram import EngramClient, HybridRetrieval

engram = EngramClient(api_key=os.environ[“ENGRAM_API_KEY”])

llm = anthropic.Anthropic()

user_id = “alice”

recent = [] # short-term: last few turns only

def agent_turn(user_input: str) -> str:

# 1) Recall long-term memory

results = engram.memories.search(

query=user_input,

user_id=user_id,

group=”default”,

retrieval_config=HybridRetrieval(limit=5),

)

memory_context = “\n”.join(f”- {m.content}” for m in results) or “- (none yet)”

system = f”””You are a helpful agent with persistent memory.

What you remember about this user:

{memory_context}

Use memories when relevant. Do not invent facts not present here or in the chat.”””

recent.append({“role”: “user”, “content”: user_input})

# 2) Act with short-term context + recalled memory

response = llm.messages.create(

model=”claude-sonnet-4-5-20250929″,

max_tokens=1024,

system=system,

messages=recent[-6:], # last ~3 exchanges

)

assistant = response.content[0].text

recent.append({“role”: “assistant”, “content”: assistant})

# 3) Remember asynchronously

engram.memories.add(

[recent[-2], recent[-1]],

user_id=user_id,

group=”default”,

)

return assistant

This pattern replaces growing history with search + a small recent window, which cuts tokens while keeping personalization.

Give the agent control with tools

Automatic recall before every turn is simple. Tool-based recall is more powerful for multi-step agents.

Expose Engram as tools:

This matches the Hermes Agent plugin model (engram_search, engram_store, engram_fetch).

Sketch:

tools = [

{

“name”: “search_memory”,

“description”: “Search long-term memories about the current user.”,

“input_schema”: {

“type”: “object”,

“properties”: {“query”: {“type”: “string”}},

“required”: [“query”],

},

},

{

“name”: “store_memory”,

“description”: “Store or correct a fact about the user.”,

“input_schema”: {

“type”: “object”,

“properties”: {“content”: {“type”: “string”}},

“required”: [“content”],

},

},

]

def handle_tool(name: str, args: dict, user_id: str):

if name == “search_memory”:

return [

m.content

for m in engram.memories.search(

query=args[“query”],

user_id=user_id,

retrieval_config=HybridRetrieval(limit=5),

)

]

if name == “store_memory”:

run = engram.memories.add(args[“content”], user_id=user_id)

return {“run_id”: run.run_id, “status”: run.status}

When the agent “forgets,” it stores a correcting memory. Engram’s reconcile pipeline supersedes the old one instead of leaving contradictions in the store.

Continual learning for agents (not only users)

Engram is not limited to user preferences. Configure topics like experience or feedback so agents learn workflows over time:

• User says genre filtering should use a genres property, not near-text search.
• Engram extracts feedback, transforms it into an experience memory, and commits it.
• Next task, the agent searches experience memories and avoids the same mistake.

Scope choices matter:

• Project-wide experience — team agents improve together
• User-scoped experience — personal agents that never leak learning across users

Design patterns that work in production

1. Always pass user_id for user-scoped topics — Engram enforces isolation; do not invent a shared memory bag.
2. Use hybrid search by default — best balance of meaning and exact terms.
3. Keep short-term history short — last 2–3 exchanges + recalled memories.
4. Fire-and-forget adds; wait only when needed — e.g. before a critical next-step search.
5. Use bounded topics for profiles — one UserProfile per user, fetched into the system prompt every turn.
6. Let agents store corrections — do not delete as the primary “forget”; reconcile instead.
7. Separate groups by use case — personalization vs continual learning stay clean.

REST fallback (any language)

curl -X POST “https://api.engram.weaviate.io/v1/memories” \

-H “Authorization: Bearer $ENGRAM_API_KEY” \

-H “Content-Type: application/json” \

-d ‘{

“input”: {“string”: {“content”: [“The user prefers dark mode.”]}},

“user_id”: “alice”

}’

curl -X POST “https://api.engram.weaviate.io/v1/memories/search” \

-H “Authorization: Bearer $ENGRAM_API_KEY” \

-H “Content-Type: application/json” \

-d ‘{

“query”: “What UI preferences does the user have?”,

“user_id”: “alice”,

“retrieval_config”: {“retrieval_type”: “hybrid”, “limit”: 5}

}’

Summary

Building agents with memory is not “save the transcript.” It is extract, reconcile, scope, and retrieve.

With Weaviate Engram you get:

1. A low-latency write path (memories.add) that pipelines extraction in the background
2. Weaviate-backed search (vector / bm25 / hybrid) for relevant recall
3. Hard multi-tenant isolation by user and soft isolation by properties
4. Two integration styles: auto-recall into the prompt, or agent-controlled tools

Start with the Personalization template, wire the search → respond → store loop, then add tool-based recall and experience topics as your agent grows.

Fuel theft alerts and profitability dashboards tend to dominate the marketing conversation around fleet software, but a meaningful part of what Covixy, an Ahmedabad-based enterprise software company, builds into its Transport ERP is far less glamorous: keeping a trucking operation compliant with India’s GST and e-way bill requirements.

According to the company, its Transport ERP addresses workflows including GST compliance, e-way bill generation, and compliance-ready documentation alongside its more heavily marketed fuel-tracking and profitability features. E-way bills, required for the movement of goods above certain value thresholds under India’s GST framework, generate a significant administrative burden for transport companies managing high trip volumes, since each shipment typically requires its own bill generated and matched to the correct invoice and vehicle.

Why Compliance Automation Matters for Smaller Operators

Manual e-way bill generation and GST filing are time-consuming processes prone to human error, particularly for smaller fleet operators without dedicated accounting staff, where a mismatched invoice or a late filing can result in penalties or delayed shipments at checkpoints. Covixy positions automated compliance documentation as reducing this administrative burden, though the company has not detailed how its system handles edge cases such as multi-state shipments or amendments to previously filed e-way bills, situations that can complicate compliance workflows even with automated tools.

What to Verify Before Relying on Automated Compliance

Compliance software carries a different kind of risk than a profitability dashboard: an incorrect P&L calculation might cost a business analytical clarity, but an incorrect or missed compliance filing can result in direct regulatory penalties, making accuracy and audit trail transparency particularly important for this specific feature set. Fleet owners considering Covixy’s Transport ERP or any comparable compliance-integrated system are generally advised to confirm how the software handles filing errors, amendments, and regulatory updates, since GST and e-way bill rules have changed periodically since the framework’s introduction.

Software vendors serving India’s logistics sector generally need to update compliance modules whenever underlying tax rules change, a maintenance obligation that applies to any ERP provider handling GST and e-way bill workflows, not solely Covixy, and one worth asking about directly in terms of how quickly a vendor typically implements regulatory updates.

Multi-state operations add a further layer of complexity to e-way bill compliance, since shipments crossing state lines can be subject to additional verification and documentation requirements that differ subtly from purely intra-state movements, a distinction that matters for larger fleets operating across a wider geographic footprint than a company running exclusively within a single state.

Audit readiness is another practical consideration tied to compliance software: tax authorities can request historical documentation during an audit, meaning a system’s ability to retrieve and present past e-way bills and GST filings quickly and accurately matters as much as its ability to generate new documents correctly at the point of shipment.

Integration with a fleet’s existing accounting software is another practical factor that determines how much manual reconciliation remains necessary even with automated compliance features, since a Transport ERP generating e-way bills in isolation from a company’s broader bookkeeping system can still leave gaps that require manual cross-checking between the two platforms.

Visit- https://www.covixy.com

Cost overruns and unexpected fees are a common complaint among businesses that have worked with outsourced software development shops, and AppDevelopers.mobile, a Gurgaon-based team of Mobile app developers, markets transparent pricing with “zero hidden costs” as a core part of its client pitch.

According to the company, its pricing structure is designed to give clients clarity on costs upfront across its various engagement models, which include project-based development, dedicated developer hiring, hourly consulting, and contract-based work. The company has not published a specific rate card or pricing methodology publicly, meaning prospective clients would need to request a quote directly to see how the transparency claim translates into an actual project estimate.

Why Development Costs Often Balloon

Cost overruns in custom software development commonly stem from scope changes requested mid-project, underestimated complexity in the original quote, or unclear boundaries around what counts as a “revision” versus new work requiring additional billing — issues that can arise with any development vendor regardless of how clearly its initial pricing is presented. AppDevelopers.mobile’s emphasis on transparent, upfront pricing addresses the initial quote stage specifically, though how the company handles pricing for scope changes or revisions that emerge after a project begins was not detailed in its publicly available information.

What “Transparent” Should Mean in Practice

A genuinely transparent pricing model typically includes clear documentation of what’s included in a quoted price, how additional work outside that scope gets billed, and what payment milestones look like across a project’s timeline — details that matter more in practice than the general marketing claim of “no hidden costs” on its own. Businesses evaluating any development partner’s pricing, AppDevelopers.mobile included, are generally advised to request a detailed, itemized quote and ask specifically how scope changes are priced before signing a contract, rather than relying on a general transparency claim alone.

The company’s various engagement models — from hourly consulting to full project-based development — likely carry different pricing structures suited to each model’s specific risk profile, since hourly and project-based pricing typically allocate cost overrun risk differently between a client and a development vendor.

Fixed-price project quotes generally shift overrun risk onto the development vendor, which can incentivize a firm to scope conservatively or push back harder on mid-project change requests, while hourly billing shifts that same risk onto the client, who pays for however long a task actually takes regardless of the original estimate. Understanding which model a specific engagement falls under helps set realistic expectations for how scope changes will actually be handled once a project is underway.

Payment milestone structure is another practical detail worth clarifying before a project begins: whether payments are tied to calendar dates, specific deliverables, or a mix of both affects how much leverage a client retains if a project falls behind schedule, a consideration that applies to any development engagement regardless of which firm is doing the work.

Comparing quotes across multiple development shops for the same project scope remains one of the more reliable ways to gauge whether a specific price is reasonable, since cost benchmarks vary considerably by region, technology stack and project complexity, making a single quote difficult to evaluate in isolation without something to compare it against.

Visit- https://appdevelopers.mobile/