GitDealFlow × Letta

What you can build

Letta agent with GitDealFlow tool

# pip install letta-client letta requests
# Run `letta server` first, then:
from letta_client import Letta
import requests

A2A = "https://signals.gitdealflow.com/api/a2a"

# Define the tool as a plain Python function. Letta uses the docstring
# and signature to auto-generate the JSON schema.
def gitdealflow_query(skill: str, args: dict = None) -> dict:
    """Live VC engineering signals from GitDealFlow.

    Args:
        skill (str): One of get_trending_startups, search_startups_by_sector,
                     get_startup_signal, get_signals_summary, get_methodology.
        args (dict): Skill-specific arguments (e.g. {"sector": "ai-ml"}).

    Returns:
        dict: JSON-RPC response with .result.artifacts[0].parts[0].data
              containing the structured payload.
    """
    body = {
        "jsonrpc": "2.0", "id": 1,
        "method": "message/send",
        "params": {"message": {"role": "user", "parts": [
            {"kind": "data", "data": {"skill": skill, "args": args or {}}},
        ]}},
    }
    return requests.post(A2A, json=body, timeout=15).json()

client = Letta(base_url="http://localhost:8283")

# Upload tool, then create a stateful agent that uses it
tool = client.tools.upsert_from_function(func=gitdealflow_query)

agent = client.agents.create(
    name="vc_scout",
    memory_blocks=[
        {"label": "persona", "value": "I am a VC analyst that tracks engineering acceleration across 350+ startups. I remember every startup I've seen and refine my thesis over time."},
        {"label": "human", "value": "The user is an investor or dealmaker who writes angel checks but doesn't read code."},
    ],
    tool_ids=[tool.id],
    model="openai/gpt-5.4",
    embedding="openai/text-embedding-3-small",
)

response = client.agents.messages.create(
    agent_id=agent.id,
    messages=[{"role": "user", "content": "What's accelerating in fintech this week?"}],
)
print(response.messages[-1].content)

Persistent scouting memory across sessions

# Same agent, weeks later. The agent remembers prior context.
from letta_client import Letta

client = Letta(base_url="http://localhost:8283")

# Reuse the agent_id from the prior session.
agent_id = "agent-..."  # persisted in your DB

# Letta auto-recalls relevant archival entries. The agent will:
# 1. Surface that Roboflow was tracked 8 weeks ago at warm signal.
# 2. Re-query GitDealFlow for the *current* signal.
# 3. Compute the delta and reason about it in conversation.
response = client.agents.messages.create(
    agent_id=agent_id,
    messages=[{"role": "user", "content": "Has anything I tracked changed materially?"}],
)
print(response.messages[-1].content)

# Inspect the agent's accumulated archival memory.
archival = client.agents.archival_memory.list(agent_id=agent_id, limit=20)
for entry in archival:
    print(entry.text[:160])

Five prompts to try first

• ›What's accelerating in fintech this week? Remember the names for next time.
• ›Has anything I tracked changed materially since last month?
• ›Show me my entire watchlist with the current commit velocity for each.
• ›Refine your persona block: focus on dev-tools breakouts under 10 contributors.
• ›Cite the SSRN methodology and store it in your archival memory for future reference.

FAQ

Gotchas

• Letta's archival memory grows over time; if you're cost-sensitive, set archival_memory_size limits in agent config or periodically prune via the API.
• Tool docstrings are the single source of truth for JSON schema, keep arg descriptions tight and accurate or the LLM picks wrong skills.
• Local-only mode (no server) works for prototyping but loses persistence across script restarts; run `letta server` for stateful agents.

References

Other frameworks

• LangChain
• CrewAI
• Mastra
• Vercel AI SDK

When the free signal isn’t enough