<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[ECHO — Engineering Intelligence]]></title><description><![CDATA[ECHO — Engineering Intelligence]]></description><link>https://echoengineering.hashnode.dev</link><generator>RSS for Node</generator><lastBuildDate>Wed, 18 Nov 2026 17:47:43 GMT</lastBuildDate><atom:link href="https://echoengineering.hashnode.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[I Built RECALL AI to Help Support Agents Remember What Already Happened]]></title><description><![CDATA[Building a customer support prototype with persistent memory, FastAPI, Supabase, Groq, and Hindsight. A customer contacts support because their Bluetooth…]]></description><link>https://echoengineering.hashnode.dev/recall-ai</link><guid isPermaLink="true">https://echoengineering.hashnode.dev/recall-ai</guid><dc:creator><![CDATA[AARJAV JAIN]]></dc:creator><pubDate>Sun, 08 Nov 2026 16:16:24 GMT</pubDate><content:encoded><![CDATA[<p><em>Building a customer support prototype with persistent memory, FastAPI, Supabase, Groq, and Hindsight.</em></p>
<p>A customer contacts support because their Bluetooth headphones keep disconnecting. The agent suggests restarting Bluetooth. The customer tries it, but the problem continues.</p>
<p>When that customer comes back later, a support assistant should be able to use that history. It should know that the issue is recurring and that the first suggestion did not help. Otherwise, the customer may have to explain everything again—and could receive the same advice again.</p>
<p>That is the problem I set out to explore with <strong>RECALL AI</strong>, a customer support prototype that combines an AI-assisted support workflow with persistent memory.</p>
<h2>The problem: a transcript is not useful memory by itself</h2>
<p>A conversation log can tell us what was said. A support agent also needs to understand what happened:</p>
<ul>
<li>The customer reported a recurring problem.</li>
<li>The agent suggested a troubleshooting step.</li>
<li>The customer later said the step did not work.</li>
<li>The issue is still unresolved.</li>
</ul>
<p>Those are different facts. In particular, an agent's suggestion does not prove that the customer tried it, and an unresolved problem should not be marked fixed without customer confirmation.</p>
<p>RECALL AI explores how to keep those distinctions available across support sessions.</p>
<h2>The stack</h2>
<p>The project has a React and TypeScript dashboard backed by a FastAPI application. Supabase PostgreSQL stores structured application data such as customers, conversations, messages, and support activity. Groq provides language-model responses, and Hindsight provides the persistent memory layer.</p>
<p>The separation is useful: Supabase is the application's record store, while Hindsight is used to retain and retrieve contextual information that can inform later conversations.<br />\</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ad4fc726e117c2c15823982/9e801394-569d-4836-b88a-6af641a38d76.jpg" alt="" style="display:block;margin:0 auto" />

<h2>How I integrated Hindsight</h2>
<p>I kept the Hindsight integration behind a small client factory and a <code>MemoryService</code>. The factory reads the configured base URL and API key from backend settings and creates the SDK client only when credentials are present:</p>
<pre><code class="language-python">def create_hindsight_client(settings: Settings) -&gt; Hindsight | None:
    if not settings.hindsight_api_key:
        return None

    return Hindsight(
        base_url=str(settings.hindsight_base_url),
        api_key=settings.hindsight_api_key.get_secret_value(),
        timeout=20.0,
        max_attempts=1,
    )
</code></pre>
<p>The service wraps Hindsight's asynchronous operations so the rest of the application can work with workspace and subject identities instead of constructing bank IDs itself. It uses three memory operations:</p>
<ul>
<li><strong>Retain</strong> saves useful facts from an interaction.</li>
<li><strong>Recall</strong> retrieves facts relevant to the customer's current message.</li>
<li><strong>Reflect</strong> asks Hindsight to synthesise an answer from a customer's stored memory when that kind of summary is useful.</li>
</ul>
<p>For example, the recall path is a small call through the service:</p>
<pre><code class="language-python">bank_id = await self.ensure_bank(workspace_id, subject_id, subject_type=subject_type)
return await self.client.arecall(
    bank_id=bank_id,
    query=query,
    include_source_facts=True,
    tags=tags,
    tags_match=tags_match,
)
</code></pre>
<p>The <code>include_source_facts</code> option helps the application inspect where recalled information came from before using it. The service also wraps SDK errors in application-level memory errors, so the API can handle an unavailable memory service consistently.</p>
<img src="https://cdn.hashnode.com/uploads/covers/6ad4fc726e117c2c15823982/b1093d89-7d2e-4478-ad77-e3a666f7caef.png" alt="" style="display:block;margin:0 auto" />

<h2>Giving each customer a scoped memory bank</h2>
<p>The backend's <code>MemoryService</code> derives a Hindsight bank ID from the workspace, subject type, and canonical customer or visitor UUID. It uses HMAC-SHA256 with a dedicated secret, so raw customer identifiers do not appear in the bank name.</p>
<pre><code class="language-python">message = "\0".join(
    ("workspace", workspace_id, "subject", subject_type, canonical_id)
).encode("utf-8")

digest = hmac.new(
    self._bank_id_secret.encode("utf-8"),
    message,
    hashlib.sha256,
).hexdigest()

return f"{self.bank_prefix}-{digest}"
</code></pre>
<p>This creates deterministic, workspace- and subject-scoped identifiers. It is an identifier strategy; authentication and authorization still belong to the application.</p>
<p>The memory service also gives Hindsight retention guidance to distinguish reported problems, attempted steps, failed attempts, successful fixes, preferences, confirmed resolutions, and unresolved issues. It explicitly says not to infer that an issue is resolved without confirmation.</p>
<p>When an interaction finishes, the workflow retains customer-reported text, the assistant response, and extracted model suggestions as separate records. It tags and labels their provenance; suggestions are marked unverified. When a customer explicitly reports a previously recommended action failed, the application links that report to the prior recommendation and retains a separate failed-attempt record with metadata describing the customer report. That lets later retrieval distinguish “the model suggested this” from “the customer says they tried this and it failed.”</p>
<h2>Recall comes before response generation</h2>
<p>A central design choice is to retrieve relevant memory before asking Groq to generate a response. In the support agent, the workflow recalls memory for the current workspace and customer, then prepares a bounded context for the model.</p>
<p>That context includes provenance checks and any relevant failed troubleshooting actions. After generation, the application checks the response against known failed-action constraints. If it cannot validate that a response avoids a reported failed step, the workflow can escalate instead of treating the generated answer as safe to send.</p>
<p>The ordering matters: memory informs the response while it is being generated. It is not attached after the fact.</p>
<h2>Following a support interaction through the system</h2>
<p>At a high level, a message moves through these stages:</p>
<ol>
<li>The frontend sends it to the FastAPI backend with workspace context and an idempotency key.</li>
<li>The backend validates the request and loads the relevant conversation context.</li>
<li>The support agent retrieves relevant customer memory from Hindsight.</li>
<li>Groq generates a structured response using the current issue and prepared context.</li>
<li>The workflow applies its failed-action checks and handles escalation where needed.</li>
<li>Conversation data is saved in Supabase, and relevant information is submitted for memory retention.</li>
</ol>
<p>The project also includes a development-only demo endpoint for a synthetic customer journey. It is guarded by development configuration and explicit demo seeding, rather than intended as a public customer endpoint.</p>
<h2>A three-stage example</h2>
<p>The repository includes a synthetic customer demonstration built around Sarah and a recurring Bluetooth issue.</p>
<p><strong>First interaction:</strong> Sarah reports that her headphones disconnect about every ten minutes. The initial troubleshooting suggestion does not solve the problem.</p>
<p><strong>Follow-up:</strong> Sarah returns and reports that forgetting and re-pairing the headphones did not help. The workflow can associate that reported failure with a previously recommended action and retain it with provenance.</p>
<p><strong>Later session:</strong> Sarah asks for another step based on her support history. The agent can use the recalled context to move toward a different diagnostic direction, such as checking for headphone firmware or operating-system updates.</p>
<p>This is a demonstration of the intended workflow, not a guarantee that every repeated recommendation will always be prevented. The application currently models a bounded set of troubleshooting actions, and memory quality depends on what was reported, retained, and retrieved.</p>
<h2>What I learned</h2>
<p>Persistent memory is more than storing a longer transcript. The system needs to keep track of who reported a fact, whether an action was suggested or attempted, and whether an outcome was confirmed.</p>
<p>I also learned that retrieval alone is not enough. Even when relevant history is available, the application still needs checks around how the generated response uses it. RECALL AI combines memory with application-level provenance and response validation for the supported troubleshooting actions.</p>
<p>The boundary between a working prototype and a production support platform matters too. The project has a development demo and a broad backend test suite, but those do not establish production reliability. Live-service behavior, security configuration, operational monitoring, broader action coverage, and realistic evaluation still need further work before a production deployment.</p>
<h2>What's next</h2>
<p>The next steps are to expand the supported troubleshooting actions, evaluate memory relevance across more scenarios, and test longer multi-session support journeys. I would also want to validate behavior against live integrations and strengthen the operational pieces required for deployment.</p>
<p>The goal is straightforward: support should build on what has already happened. Customers should not have to repeat their history, and an agent should have a way to recognise when a suggested fix has already failed.</p>
<p><strong>Project:</strong> <a href="https://github.com/aarjavjain7/customer_support_agent">RECALL AI on GitHub</a></p>
<p><strong>Technologies:</strong> React, TypeScript, FastAPI, Supabase, Groq, and Hindsight</p>
]]></content:encoded></item><item><title><![CDATA[ECHO: Giving AI Agents a Graph-Powered Memory of Software Projects]]></title><description><![CDATA[The Problem: Software Projects Have Connected Context Software projects generate a constant stream of decisions, dependencies, tasks, and technical…]]></description><link>https://echoengineering.hashnode.dev/echo-giving-ai-agents-a-graph-powered-memory-of-software-projects</link><guid isPermaLink="true">https://echoengineering.hashnode.dev/echo-giving-ai-agents-a-graph-powered-memory-of-software-projects</guid><dc:creator><![CDATA[AARJAV JAIN]]></dc:creator><pubDate>Sun, 18 Oct 2026 17:18:11 GMT</pubDate><enclosure url="https://cdn.hashnode.com/uploads/covers/6ad4fc726e117c2c15823982/ecd44102-a649-4d37-9073-6423f4b4dfb2.jpg" length="0" type="image/jpeg"/><content:encoded><![CDATA[<p>The Problem: Software Projects Have Connected Context</p>
<p>Software projects generate a constant stream of decisions, dependencies, tasks, and technical discussions. The challenge is not simply storing this information — it is understanding how the pieces connect.</p>
<p>For example, changing an authentication design may affect several downstream tasks. A conventional task list might show the individual tasks, but understanding the consequences requires tracing their relationships.</p>
<p><strong>ECHO is a graph-powered project memory agent designed to make those relationships easier to explore and explain.</strong></p>
<h2>What Is ECHO?</h2>
<p>ECHO stands for a graph-powered approach to project memory and impact intelligence. It is a Python-based prototype built around FalkorDB.</p>
<p>Its goal is to help developers answer questions such as:</p>
<ul>
<li><p>Which tasks could be affected by a technical decision?</p>
</li>
<li><p>What relationship connects a decision to a downstream task?</p>
</li>
<li><p>What project memories are associated with a particular subject?</p>
</li>
<li><p>Which earlier decision was superseded by a newer one?</p>
</li>
</ul>
<p>Rather than treating project information as disconnected notes, ECHO models entities and their relationships in a graph.</p>
<h2>Why Use a Graph Database?</h2>
<p>Project context is inherently connected. Tasks depend on other tasks, decisions affect parts of a project, memories relate to specific subjects, and decisions can supersede earlier decisions.</p>
<p>A graph represents these connections explicitly.</p>
<p>ECHO uses FalkorDB as its primary graph database and Cypher queries to traverse relationships, retrieve relevant information, and explain how connected entities relate to one another.</p>
<p>The graph is central to the prototype's functionality, rather than simply being a visualization layer.</p>
<h2>Three Core Capabilities</h2>
<h3>1. Graph-Based Impact Analysis</h3>
<p>A technical decision can have consequences beyond the component it directly changes.</p>
<p>ECHO traverses graph relationships to identify downstream tasks that may be affected. It also returns evidence paths that help explain why a task was included in the impact analysis.</p>
<p>In the synthetic demonstration dataset, ECHO identifies <strong>seven potentially affected tasks</strong> for a sample decision and shows the graph paths supporting those results.</p>
<p>This makes the output more inspectable than a list of task names without supporting evidence.</p>
<h3>2. Persistent Project Memory</h3>
<p>ECHO supports storing project memories and linking them to relevant subjects in the graph.</p>
<p>This structure makes it possible to retrieve memories associated with a particular project entity instead of relying only on isolated text entries.</p>
<p>The prototype also supports optional recording provenance, allowing a memory to be associated with information about who recorded it or where it came from when those details are provided.</p>
<h3>3. Decision History</h3>
<p>Project decisions change over time. A newer decision may replace an earlier one, but the earlier decision can still provide useful historical context.</p>
<p>ECHO represents this relationship with a <code>SUPERSEDES</code> edge from the newer decision to the older decision.</p>
<p>Its decision-history functionality can retrieve connected earlier and later decisions, helping preserve context about how project choices evolved.</p>
<p>The current implementation focuses on connected decision history rather than providing a complete branching history interface.</p>
<h2>How FalkorDB Powers ECHO</h2>
<p>FalkorDB is the primary graph database in ECHO.</p>
<p>The prototype models project entities, tasks, decisions, and memories as nodes. Relationships represent connections such as dependencies, impact, subject associations, and decision supersession.</p>
<p>Python connects the application to FalkorDB, while Cypher queries perform graph traversals and retrieve connected information.</p>
<p>This enables ECHO to combine three important capabilities:</p>
<ul>
<li><p><strong>Relationship-aware retrieval:</strong> find information through graph connections.</p>
</li>
<li><p><strong>Explainable impact analysis:</strong> show evidence paths connecting a decision to affected tasks.</p>
</li>
<li><p><strong>Persistent decision context:</strong> connect memories with project entities and preserve relationships between decisions.</p>
</li>
</ul>
<p>These capabilities demonstrate how graph databases can serve as a foundation for practical AI-agent memory and connected-data reasoning.</p>
<h2>Testing the Prototype</h2>
<p>ECHO was tested locally against a running FalkorDB instance using synthetic project data.</p>
<p>The verification process included automated tests and repeatable demonstration scripts.</p>
<p>The project test suite passed <strong>63 tests</strong> in the verified local environment. The impact-analysis demonstration identified seven affected tasks, and the memory demonstration exercised memory retrieval and decision-history behavior.</p>
<p>These results validate the tested prototype behavior; they do not establish production readiness or performance at large scale.</p>
<h2>What I Learned</h2>
<p>Building ECHO reinforced three important ideas.</p>
<p><strong>First, relationships can be as important as the information itself.</strong> A task or decision becomes more useful when its connections to other project entities are explicit and queryable.</p>
<p><strong>Second, explanations matter.</strong> An impact-analysis result is more useful when a developer can inspect the path connecting the original decision to the affected task.</p>
<p><strong>Third, verification matters when using AI-assisted development.</strong> AI coding tools helped with implementation, while I ran the tests and demonstrations against a local FalkorDB instance to check the resulting behavior.</p>
<h2>Current Limitations and Future Work</h2>
<p>ECHO is currently a prototype demonstrated with synthetic data and a local setup. It does not yet have a public hosted deployment or integrations with live software-development platforms.</p>
<p>Potential next steps include:</p>
<ul>
<li><p>A user interface for exploring project graphs and evidence paths.</p>
</li>
<li><p>Integrations with authorized issue trackers and project documentation.</p>
</li>
<li><p>More comprehensive handling of branching decision histories.</p>
</li>
<li><p>Evaluation against larger and more realistic project datasets.</p>
</li>
<li><p>Further testing of reliability, performance, and practical usefulness.</p>
</li>
</ul>
<p>These improvements would help assess how ECHO performs in real development workflows.</p>
<h2>Conclusion</h2>
<p>ECHO explores how FalkorDB can power project memory and impact analysis by making relationships between tasks, decisions, and memories explicit.</p>
<p>Its current prototype combines graph-based impact analysis, evidence-path explanations, persistent memory retrieval, and decision-history queries.</p>
<p>The central idea is simple: <strong>when project knowledge is connected, an agent can do more than retrieve isolated facts — it can follow relationships and show how pieces of context fit together.</strong></p>
<h3>Explore the Project</h3>
<p>Source code, setup instructions, and demonstration scripts:</p>
<p><a href="https://github.com/aarjavjain7/ECHO-Graph-Powered-Project-Memory-Agent">GitHub: ECHO — Graph-Powered Project Memory Agent</a></p>
<p>ECHO is a work in progress, and the current implementation is a locally tested prototype built with Python and FalkorDB.</p>
]]></content:encoded></item></channel></rss>