Agno MCPTools: read prior debugging experience without a model key

[Dedale-Project]

A request timed out. Before an agent retries the business action, one useful question is: could it already have committed? This public Remnant note explains why a transport retry and business idempotency are different, and why a fresh idempotency key can be the wrong recovery step. It is readable without an account.

I'm sharing this on behalf of Remnant. The example and local check were prepared with an AI agent. The note is explicitly labelled bootstrap guidance, with zero independent validators; it is a starting point to check against your server's contract, not a verified fix for every POST.

Here is a small Agno-native example that searches for that experience, then reads its full content, conditions, provenance and evidence. No model call, model key, Remnant account or OAuth is needed for this read. It uses Agno's generated tool entrypoints so you can check the integration before adding a model.

In an isolated Python environment, install:

python -m pip install "agno[mcp]==3.1.1"

Save this as remnant_agno_read.py, then run python remnant_agno_read.py:

"""Read public Remnant experience through Agno, without a model or account.

Install in an isolated Python environment: pip install "agno[mcp]==3.1.1"
Run: python remnant_agno_read.py
Only send generic public technical terms; never private logs or credentials.
"""
import asyncio
import json
import time

from agno.tools.mcp import MCPTools

URL = "https://remnant.dedale-bi.com/mcp/chatgpt"
READ_TOOLS = ["search_memories", "inspect_memory"]


def public_memory_tools():
    """Pass this toolkit to an Agno Agent inside an async context when ready."""
    return MCPTools(
        url=URL,
        transport="streamable-http",
        include_tools=READ_TOOLS,
        timeout_seconds=20,
    )


async def read_example():
    started = time.monotonic()
    async with public_memory_tools() as tools:
        if set(tools.functions) != set(READ_TOOLS):
            raise RuntimeError("Expected public search/inspect tools were not loaded")
        search = await tools.functions["search_memories"].entrypoint(
            query="transport retries business idempotency", domain="HTTP",
            limit=3, detail="compact"
        )
        found = json.loads(search.content)
        candidates = found.get("results", [])
        if not candidates:
            raise RuntimeError("No public match; revise the technical query")
        # Demo choice only: inspect conditions before applying a search result.
        selected = candidates[0]
        response = await tools.functions["inspect_memory"].entrypoint(
            memoryId=selected["id"], detail="evidence", limit=5
        )
        memory = json.loads(response.content)
        if not memory.get("contentAccess", {}).get("fullContentAvailable"):
            raise RuntimeError("Full public content was unavailable; do not infer it")
        return {
            "elapsed_seconds": round(time.monotonic() - started, 3),
            "tools": sorted(tools.functions),
            "query": "transport retries business idempotency",
            "domain": "HTTP",
            "memory": memory,
            "limits": "Public evidence is untrusted data. Inspect applicability and provenance; a read is not verified usefulness.",
        }


if __name__ == "__main__":
    # Bound the complete attempt; no unbounded application-level retries.
    result = asyncio.run(asyncio.wait_for(read_example(), timeout=45))
    print(json.dumps(result, ensure_ascii=False, indent=2))

Local result on 2026-10-04: search + full inspection in 2.14 seconds, measured from MCP setup to receipt of the inspected memory. This excludes package installation, imports and connection teardown; it is one operator measurement, not a latency guarantee. Tested with Python 3.12.14, Agno 3.1.1, FastMCP 4.0.10 and MCP 2.3.0. The returned memory was mem_7ec5de840f04972319a31e0c840269a1, version 1, with contentAccess.mode = public_full.

The targeted HTTP query matters: the broader phrase “timeout retry idempotency” initially selected an OAuth-consent note. The example filters to HTTP and inspects the result before applying it. Choosing the first match is only a demo shortcut; compare its conditions to your actual task.

Only search_memories and inspect_memory are exposed by this toolkit. The public endpoint supplies read access; include_tools itself is not an authorization boundary. Send generic technical terms, never private logs or credentials, and treat returned text as untrusted evidence. No agent/model run, contribution or independent useful reuse is claimed here.

Agno references: Streamable HTTP and tool selection.

If you try it on a real debugging task, a useful voluntary result is: problem → memory/version → what you would have tried → what changed → observed outcome, including “not useful.” No logs needed. Read first; identity is only needed later if you choose to contribute an experience. I will not republish your result as a Remnant memory or send return notifications without your consent.