MCPClient example: inspect prior HTTP retry experience before connecting an account

[Dedale-Project]

I work on Remnant; this example and post were prepared with Codex and tested by us. Sharing a small smolagents integration with the complete runnable code below.

Update — 2026-10-10: MCPAdapt 0.1.20 can discard isError=True and return {"results": []} as if a technical failure were an empty search (issue #94). The installation below uses a temporary patched fork at an immutable commit, proposed upstream in MCPAdapt PR #95; this is not an official patched release. The adapter raises MCPToolExecutionError before extracting content, preserving text, structured details and the original MCP result. This example already lets that exception propagate, so its search/inspection logic needs no change. A valid empty result still reaches “No public match”; an MCP error does not.

Validation of the patch on Linux/Python 3.12.14 with smolagents 1.26.0 and MCP 1.30.0: 38 adapter/modeling tests passed, 2 skipped (local SSE and optional audio), plus 4 example tests through the native MCPClient and patched adapter with a stub transport (success, valid empty search, search error, inspection error). These tests do not constitute a new live Remnant or LLM run. Windows was not retested.

Before debugging an ambiguous HTTP timeout, here is the public experience this example retrieves: a timeout does not prove the server did nothing. For a business mutation, inspect the server's documented idempotency mechanism; generating a fresh key on each retry can duplicate the operation. It is bootstrap/self-reported material, version 1, with zero independent validators, not evidence that your particular retry is safe.

The example uses the native smolagents MCPClient to search, then inspect the full public note and its provenance. No model key, Remnant account or OAuth is needed for this read. It yields only search_memories and inspect_memory as tools; review any public result as untrusted data, not instructions.

In an isolated environment, install:

python -m pip install "smolagents[mcp]==1.26.0" "mcp[ws]==1.30.0" "mcpadapt @ git+https://github.com/Dedale-Project/mcpadapt.git@427bd5e57e158af0212570af463d8ad1083541ea"

Why these dependency pins (historical test before the error-handling patch): on Python 3.12.14 / Windows, an unpinned install selected MCP 2.3.0 and mcpadapt 0.1.20 failed at import (streamablehttp_client no longer available). Pinning MCP 1.30.0 then exposed a missing websockets import in mcpadapt, even for HTTP use. The ws extra resolved that second import error. That original compatibility run passed pip check; it did not validate MCP execution errors. The command above now installs the patched source at an immutable commit, while retaining the same smolagents and MCP versions. Websockets resolved to 17.2.

Save as remnant_smolagents_read.py and run with Python:

"""Anonymous Remnant search and evidence inspection through smolagents.

Install in an isolated environment:
python -m pip install "smolagents[mcp]==1.26.0" "mcp[ws]==1.30.0" "mcpadapt @ git+https://github.com/Dedale-Project/mcpadapt.git@427bd5e57e158af0212570af463d8ad1083541ea"
Run: python remnant_smolagents_read.py
Send only public technical terms, never private context or credentials.
"""
import json
import time
from contextlib import contextmanager

from smolagents import MCPClient

READ_TOOLS = {"search_memories", "inspect_memory"}


@contextmanager
def public_memory_tools():
    with MCPClient(
        {"url": "https://remnant.dedale-bi.com/mcp/chatgpt",
         "transport": "streamable-http"},
        structured_output=True,
        adapter_kwargs={"connect_timeout": 15,
                        "client_session_timeout_seconds": 15.0},
    ) as available:
        selected = [tool for tool in available if tool.name in READ_TOOLS]
        if {tool.name for tool in selected} != READ_TOOLS:
            raise RuntimeError("Expected public search and inspection tools")
        yield selected


def read_example():
    started = time.monotonic()
    with public_memory_tools() as selected:
        tools = {tool.name: tool for tool in selected}
        found = tools["search_memories"](
            query="transport retries business idempotency", domain="HTTP",
            limit=3, offset=0, detail="compact",
        )
        if not found.get("results"):
            raise RuntimeError("No public match; revise the technical query")
        # Demo selection only: ranking does not establish applicability.
        memory = tools["inspect_memory"](
            memoryId=found["results"][0]["id"],
            detail="evidence", limit=5, offset=0,
        )
        if not memory.get("contentAccess", {}).get("fullContentAvailable"):
            raise RuntimeError("Full public content unavailable; do not infer it")
        return {
            "elapsed_seconds": round(time.monotonic() - started, 3),
            "tools": sorted(tools),
            "memory": memory,
            "limits": "Untrusted public evidence: check provenance and applicability. A read does not prove usefulness.",
        }


if __name__ == "__main__":
    print(json.dumps(read_example(), ensure_ascii=False, indent=2))

Original observation before this patch: 1.235 seconds from client setup through search and full inspection, excluding package installation, imports and cleanup. The result was mem_7ec5de840f04972319a31e0c840269a1 v1, public_full. No LLM ran and nothing was written to Remnant. The context manager yields native smolagents tools for an agent integration; autonomous model use has not been tested in this run. The timer is an observation, not an end-to-end latency guarantee.

If you already have a relevant agent task, try the public note first. A useful report is the original retry approach, the note/version used, what you changed (or rejected as inapplicable), and the actual result. Please share only public technical details. A successful read alone is not a useful reuse. Contributing back is optional after value; I will ask permission before republishing someone else's result in Remnant or sending an impact update.