AutoGen Integration

pip install "mubit-autogen[autogen]"
# AutoGen over-pins protobuf<6 while mubit-sdk needs >=6.33 — apply after install:
pip install -U "protobuf>=6.33.4"

import asyncio
 
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from mubit_autogen import MubitMemory
 
memory = MubitMemory(
    endpoint="https://api.mubit.ai",
    api_key="mbt_...",
    session_id="support-1",       # the Mubit run that backs this memory
    agent_id="support-assistant",
)
 
agent = AssistantAgent(
    name="support",
    model_client=OpenAIChatCompletionClient(model="gpt-4o"),
    memory=[memory],  # Mubit recall is injected before every model turn
)
 
async def main() -> None:
    result = await agent.run(task="Customer says checkout 500s on Safari.")
    print(result.messages[-1].content)
 
asyncio.run(main())

import asyncio
import os
 
from autogen_agentchat.agents import AssistantAgent
from autogen_core.memory import MemoryContent, MemoryMimeType
from autogen_ext.models.openai import OpenAIChatCompletionClient
 
from mubit_autogen import MubitMemory, extract_entry_ids
 
NEW_TICKET = (
    "Checkout fails with a 500 error on Safari. Works fine in Chrome. "
    "I'm on a Pro plan and need to renew today."
)
 
async def main() -> None:
    memory = MubitMemory(
        endpoint=os.environ.get("MUBIT_ENDPOINT", "https://api.mubit.ai"),
        api_key=os.environ["MUBIT_API_KEY"],
        session_id="support-assistant",   # stable -> cross-session recall
        agent_id="support-assistant",
    )
    model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
 
    # 1. RECALL — query directly so we can capture the reference IDs.
    # (The same recall is auto-injected into the model context during agent.run.)
    recalled = await memory.query(NEW_TICKET, limit=5)
    entry_ids = memory.extract_entry_ids(recalled)
 
    # 2. ACT — the attached memory injects recalled context as a SystemMessage.
    agent = AssistantAgent(
        name="support_assistant",
        model_client=model_client,
        memory=[memory],
        system_message="Use recalled prior tickets to give a concrete resolution.",
    )
    result = await agent.run(task=NEW_TICKET)
    answer = result.messages[-1].content
 
    # Persist the new resolution so future sessions can recall it (idempotent).
    await memory.add(MemoryContent(
        content=f"[safari-500] Resolution: {answer}",
        mime_type=MemoryMimeType.TEXT,
        metadata={"intent": "trace", "idempotency_key": "resolution-safari-500"},
    ))
 
    # 3. RECORD — credit every recalled entry that contributed.
    memory.record_step_outcome(
        step_id="answer-ticket", step_name="draft-resolution", outcome="success",
    )
    memory.record_outcome(
        outcome="success",
        entry_ids=entry_ids,            # credit the recalled entries
        verified_in_production=True,    # boost lessons confirmed in live use
        rationale="Resolved the Safari 500 using prior gateway lessons.",
    )
 
    await model_client.close()
    await memory.close()
 
asyncio.run(main())

import asyncio
import os
 
from autogen_agentchat.agents import AssistantAgent
from autogen_ext.models.openai import OpenAIChatCompletionClient
from mubit_autogen import MubitMemory, MubitGroupChatHook
 
endpoint = os.environ.get("MUBIT_ENDPOINT", "https://api.mubit.ai")
api_key = os.environ["MUBIT_API_KEY"]
SESSION = "autogen-team-1"
 
researcher_mem = MubitMemory(
    endpoint=endpoint, api_key=api_key, session_id=SESSION, agent_id="researcher",
)
reviewer_mem = MubitMemory(
    endpoint=endpoint, api_key=api_key, session_id=SESSION, agent_id="reviewer",
)
hook = MubitGroupChatHook(endpoint=endpoint, api_key=api_key, session_id=SESSION)
 
async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
 
    researcher = AssistantAgent(
        name="researcher", model_client=model_client, memory=[researcher_mem],
    )
    reviewer = AssistantAgent(
        name="reviewer", model_client=model_client, memory=[reviewer_mem],
    )
 
    findings = await researcher.run(
        task="Investigate why billing discrepancies spiked this week."
    )
    handoff = hook.emit_handoff(
        from_agent_id="researcher", to_agent_id="reviewer",
        task_id="billing-review-1",
        content=str(findings.messages[-1].content)[:1000],
        requested_action="review",
    )
 
    review = await reviewer.run(task="Review the researcher's billing findings.")
    hook.emit_feedback(
        handoff_id=handoff.get("handoff_id", "billing-review-1"),
        from_agent_id="reviewer",
        verdict="approve",
        comments=str(review.messages[-1].content)[:1000],
    )
 
    await model_client.close()
 
asyncio.run(main())

ids = memory.extract_entry_ids(result, cited_only=False)  # reference_ids off a query result
memory.extract_citations(result)                # 0-based indices of cited evidence
memory.record_outcome(outcome="success", entry_ids=ids,
                      verified_in_production=True, rationale="...")
memory.record_step_outcome(step_id="...", step_name="...", outcome="success",
                           signal=0.8, directive_hint="...")