Summary

This PR fixes issue #3723 where mem0.add() was calling the embedding API twice, unnecessarily doubling costs and latency for users.

Root Cause

The issue had two causes:

1. infer=False path: When infer=False, embeddings were passed directly to _create_memory() without a dict wrapper. The method checked if data in existing_embeddings, which failed since existing_embeddings was a vector list, not a dict, triggering a redundant embedding call.

2. infer=True path: When infer=True, facts extracted from messages were embedded and cached using the original fact text as the key. However, the LLM might rephrase these facts when generating ADD/UPDATE actions. If action_text didn't exactly match the cache key, _create_memory() would embed the text again.

Solution

1. Modified _create_memory() and _update_memory() to handle embeddings as either:

   • A dict (preferred) for efficient caching by text key
   • A precomputed vector (for backwards compatibility)

2. Updated infer=False path to wrap embeddings in a dict before calling _create_memory()

3. Added proactive caching in infer=True path: before processing ADD/UPDATE events, check if action_text is already in the cache; if not, embed it once and cache it

4. Applied all fixes to both sync (Memory) and async (AsyncMemory) classes

5. Made isinstance checks numpy-safe by using not isinstance(dict) instead of isinstance(list), so embedding models returning numpy arrays or other vector types are handled correctly

6. Added type hints (Union[Dict[str, List[float]], List[float]]) to existing_embeddings parameter on all four methods to document the dual contract

Testing

Automated tests (all passing)

• tests/test_memory.py — 24/24 passed, including 3 regression tests for this fix:
  • test_add_infer_false_embeds_once — verifies infer=False path calls embed exactly once
  • test_add_infer_true_caches_embedding_on_llm_rewrite — verifies infer=True ADD path pre-caches rewritten text, no redundant embed inside _create_memory
  • test_update_infer_true_caches_embedding_on_llm_rewrite — verifies infer=True UPDATE path pre-caches rewritten text, no redundant embed inside _update_memory
• tests/memory/test_main.py — 12/12 passed (timestamps, error handling, async variants)
• tests/memory/test_graph_memory_soft_delete.py — 20/20 passed
• tests/memory/ full directory — 216 passed, 43 skipped (skips are external services like Neo4j/Kuzu)
• tests/llms/test_openai.py — 7/7 passed
• tests/vector_stores/test_qdrant.py — 58/58 passed
• tests/embeddings/test_openai_embeddings.py — 6/6 passed

Backward compatibility verification

• All 15 call sites of _create_memory and _update_memory (across production code and tests) were audited — every one passes a dict, so the primary code path is unchanged
• The not isinstance(dict) fallback branch is purely defensive for the documented List[float] type
• No call site ever passes None, so the relaxed check introduces no new failure modes

Manual testing

• Confirmed both infer=True and infer=False paths now reuse cached embeddings
• Verified no double embedding calls via debug logging

Impact

• Performance: Eliminates redundant embedding API calls, cutting latency in half
• Cost: Reduces embedding costs by ~50% for affected operations
• Backwards compatible: No breaking changes to API

Closes #3723