Giving a Sales Agent a Memory That Persists Between Conversations

sampeta ganesh — Tue, 29 Sep 2026 09:11:51 +0000

We built DealMind to address a simple failure mode in conversational sales tools: a useful customer detail can disappear when the conversation ends. A normal conversational AI can use the context in its current chat, but it does not automatically turn every important detail into durable context for the next conversation. Sales discussions are full of facts worth retaining: a customer's interests, preferences, objections, buying intent, and competitor comparisons.

DealMind is an AI Sales Intelligence Agent designed to retain those useful customer facts and recall them later. The technical result is a memory loop around the language model: retrieve relevant context before generating an answer, then extract and retain explicit durable facts after the interaction.

Screenshot: DealMind chat interface showing persistent customer memory

The Problem We Chose to Solve

A salesperson may learn that a prospect is interested in the product, considers the annual plan expensive, prefers monthly billing, and is comparing the product with Zoho. Those facts can change what the salesperson should discuss in a later meeting. Without persistent memory, a later request such as "Prepare me for my meeting with Ravi" starts with only that request and whatever short-lived chat context is still available.

Our goal was to make customer context available across conversations without turning every previous message into an unfiltered prompt. DealMind stores useful facts in Hindsight and gives relevant recalled text to the model.

Architecture: A Memory Loop Around the Agent

The implemented request path is:

User -> React UI -> FastAPI -> DealMind Agent -> Hindsight recall -> Groq LLM -> durable fact extraction -> Hindsight retain -> response to UI

The frontend is a Vite application using React and React DOM. Submitting the composer sends JSON to the configured API URL, defaulting to http://127.0.0.1:8000, and reads response and memories. The FastAPI backend's /chat endpoint validates ChatRequest, calls agent.process_message, and returns the response plus recalled memories.

The agent identifies a customer name when possible, constructs a customer-scoped recall query, and asks Hindsight for up to ten relevant memories. It formats them as a bullet list in the prompt sent to the model, then returns the response to FastAPI and the React UI.

Screenshot: Architecture diagram

What Hindsight Does

Hindsight is the persistent memory layer; it is not the language model generating the answer. DealMind configures a Hindsight base URL, API key, and bank ID from environment variables. The service wrapper uses the Hindsight REST API with authenticated requests calls.

For recall, DealMind posts to the bank's /memories/recall endpoint. The payload includes a query, the memory types world, experience, and observation, a mid budget, a token limit derived from the requested limit, and a customer tag. The agent normalizes the returned shapes, extracts readable memory text, and passes only the recalled text into the LLM prompt.

For retention, the agent first makes a separate Groq call asking for valid JSON containing only explicit, useful, durable customer facts. The allowed categories include preferences, pricing concerns, objections, competitors, interest, buying intent, decision criteria, requirements, and follow-up details. If the JSON is invalid, the code has a conservative fallback that looks for explicit durable cues in the original message. Each retained item is sent to Hindsight with content, conversation context, a customer and memory-type tag, a deterministic document ID, and metadata.

That order matters. Hindsight supplies durable context, while Groq performs response generation and fact extraction. Hindsight does not replace Groq, and Groq does not provide persistence by itself.

Screenshot: Hindsight memory/recall behavior

Three Small Pieces of the Implementation

The recall step scopes a query to one customer and turns returned memories into prompt context:

recall_query = f"Customer: {customer}. Relevant information for this request: {message}"
recalled_items = _recall_items(
    self.memory_service.recall_memory(customer=customer, query=recall_query, limit=10)
)
memories = [text for text in (_memory_text(item) for item in recalled_items) if text]
memory_context = "\n".join(f"- {item}" for item in memories) or "No relevant memories found."

This is the boundary where persistent memory becomes usable input. The agent does not blindly paste an entire conversation archive; it asks Hindsight for relevant, customer-tagged results.

Groq generates the response from both the system rules and the current request with recalled context:

response = self.language_model.generate_response(SYSTEM_PROMPT, user_prompt)

Inside LLMService, that call becomes a Groq chat completion using the configured model and a low temperature of 0.2. The system prompt instructs DealMind to distinguish customer facts from suggestions and to avoid unsupported product or competitor claims.

After the response, the agent asks Groq to extract durable facts and retains each accepted fact:

extracted = self.language_model.generate_response(
    "You extract factual customer memory candidates. Return only the requested JSON.",
    extraction_prompt,
)
facts = _parse_extracted_facts(extracted or "", message, customer)

for fact in facts:
    self.memory_service.retain_memory(
        customer=customer,
        memory_type=fact["type"],
        value=fact["value"],
        source="dealmind_conversation",
        context=f"Conversation message: {message}",
        metadata={"customer": customer, "source": "dealmind_agent"},
    )

The extraction prompt explicitly excludes requests, temporary details, advice, and inferred facts. This keeps the memory layer focused on information likely to matter later.

Screenshot: Relevant code showing Hindsight integration

The Ravi Interaction

The repository includes this concrete two-step test scenario. First, the salesperson sends:

Ravi is interested in our software. He thinks the annual plan is expensive, prefers monthly billing, and is comparing us with Zoho.

DealMind generates a response for the current request, then extracts explicit facts such as Ravi's interest, pricing concern, billing preference, and competitor comparison. Those facts are retained under Ravi's Hindsight tag.

Later, the salesperson sends:

Prepare me for my meeting with Ravi.

The agent recognizes Ravi, recalls relevant Hindsight memories, and gives those memories to Groq. The second response can therefore mention that Ravi is interested, is concerned about the annual plan's cost, prefers monthly billing, and is comparing the product with Zoho. The test checks that stored facts exist, that the second request recalls memories, and that the response uses terms such as "monthly," "annual," "Zoho," or "interested."

Those are customer facts, not product facts. Ravi's preference for monthly billing does not prove that DealMind's product offers monthly billing. The prompt rules require unknown commercial details to be verified rather than presented as fact.

Before and After

Before: the agent has only the current conversation context. A meeting-preparation request may identify Ravi but contains no history about what he cares about.

After: the agent can use relevant persistent customer memories from previous interactions. The salesperson receives guidance grounded in Ravi's known interest, concern, preference, and comparison, while unsupported business details remain unknown and are marked for verification.

Persistence therefore provides selective, query-driven continuity rather than simply a longer prompt.

Lessons Learned

Memory needs an explicit write policy. Extracting durable facts is more useful than saving every utterance.
Recall must be scoped. Customer tags and a request-specific query reduce the chance that unrelated context is treated as relevant.
A memory about a customer's belief or preference is not evidence about the product. Grounding rules must prevent "Ravi prefers monthly billing" from becoming "monthly billing is offered."
The memory loop is testable. The Ravi test checks retention, recall, and use in the later response.
The model and memory service have different responsibilities. Keeping Groq generation separate from Hindsight recall and retention makes the data flow easier to inspect.

Limitations and Open Edges

This implementation focuses on the chat and memory loop. The backend exposes customer-memory and timeline routes, but the corresponding agent functions currently return empty arrays, so those routes are not a completed timeline feature. The /api/memory route acknowledges ingestion rather than implementing a separate workflow. The fallback fact extractor for invalid model JSON is heuristic, so retained facts still deserve review.

The repository has tests for the API contract, Ravi behavior, Hindsight connectivity and retention/recall, and a direct Groq call. Live behavior requires external credentials and a reachable Hindsight endpoint. There is no repository evidence of production hosting, autoscaling, authentication, or observability.

Technologies and Deployment

The project uses Python 3.11+, FastAPI, Uvicorn, Pydantic, python-dotenv, requests, Groq's Python client, and the Vectorize package listed in backend/requirements.txt. The frontend uses JavaScript, React 18, React DOM, and Vite. The React/Vite frontend is deployed on Vercel, while the FastAPI backend is deployed on Render.

Hindsight is connected through its hosted API, and Groq is used through its API. Secrets such as API keys are stored as environment variables and are not exposed in the frontend. For local development, create a Python virtual environment, install backend/requirements.txt, install the frontend npm dependencies, configure the Hindsight and Groq variables, run uvicorn backend.main:app --reload, and run npm run dev in frontend. CORS allows Vite localhost origins and an optional FRONTEND_URL.

Links and Conclusion

DealMind's central idea is modest but practical: sales context should survive the end of a chat when it is useful, explicit, and customer-specific. Hindsight provides the durable memory and retrieval layer. Groq turns the current request plus recalled facts into a response and helps identify new facts to store. The result is an agent that can prepare for the next conversation with continuity, while its grounding rules keep customer preferences separate from claims that still need verification.

DEV Community: sampeta ganesh