Samsung’s Galaxy Z Fold8 is priced from Rs 1,79,999 in India as pre-orders opened today, following its unveiling at the Galaxy Unpacked event on July 22.

The 12GB+512GB variant costs Rs 1,99,999, and the 16GB+1TB variant is priced at Rs 2,39,999. Open sales are scheduled to begin on August 8.

The phone features a 7.6-inch Dynamic AMOLED 2X foldable display with a 120Hz adaptive refresh rate and up to 3,000 nits of peak brightness, driven by the Snapdragon 8 Elite Gen 5 chipset.

Its camera system includes dual 50MP rear sensors, with a wide-angle lens offering OIS and 2x optical quality zoom, plus a 50MP ultra-wide lens.

A 4,800mAh battery supports up to 63 per cent charge in about 30 minutes through 45W wired charging, along with 20W wireless charging and Wireless PowerShare.

Weighing 201 grams, it is Samsung’s lightest Z Fold model so far, with an exchange bonus of Rs 10,000 or an instant bank discount of Rs 9,000 on offer.

(Image: Vasonesiku (CC BY-SA 4.0))

Motorola’s Edge 70 Max is now available in India, priced at Rs 54,999 for the 8GB+256GB variant and Rs 59,999 for the 12GB+256GB option. An effective price of Rs 49,999 applies with bank offers.

The device is built around a Snapdragon 8 Gen 5 chipset and includes a 6.8-inch Quad HD+ LTPO AMOLED display with a 144Hz refresh rate.

A 7100mAh silicon-carbon battery, the largest Motorola has used in a smartphone, powers the device and is rated for up to 58 hours of battery life.

The phone also supports Qi2.2 wireless charging in addition to wired fast charging.

Availability began on July 20 through Flipkart, Motorola’s website, and offline stores.

(Image: Maksdroider (CC BY 4.0))

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.