XysqAgent & Integrations

pip install 'xysq[agent]'

from xysq import Xysq, XysqAgent

with Xysq() as client:
    agent = XysqAgent(
        client=client,
        model="gpt-4o-mini",        # any LiteLLM model string
        api_key="sk-...",
        system_prompt="You are a helpful coding assistant.",
        context_strategy="surface", # "surface" | "synthesize" | "both" | "none"
        surface_budget="low",       # "low" | "mid" | "high"
    )

    reply = agent.chat("I prefer functional programming over OOP.")
    print(reply)

    # Fresh agent — memory carries over automatically
    agent2 = XysqAgent(client=client, model="gpt-4o-mini", api_key="sk-...")
    reply = agent2.chat("What are my coding preferences?")
    print(reply)

def __call__(
    self,
    client,       # the Xysq sync client
    message: str, # current user message
    turn_count: int,
    history: list[dict[str, str]],
) -> str:         # context string to inject, or "" for none
    ...

from xysq import ContextStrategy, Xysq, XysqAgent

class AdaptiveStrategy:
    """Synthesize on the first turn for a broad overview,
    then surface on follow-ups for precise recall."""

    def __init__(self, budget: str = "low") -> None:
        self.budget = budget

    def __call__(self, client, message, turn_count, history):
        if turn_count == 1:
            result = client.memory.synthesize(message, budget=self.budget)
            return f"[overview] {result.answer}" if result.answer else ""
        else:
            items = client.memory.surface(message, budget=self.budget)
            return "\n".join(f"- {m.text}" for m in items)

with Xysq() as client:
    agent = XysqAgent(
        client=client,
        model="gpt-4o-mini",
        api_key="sk-...",
        context_strategy=AdaptiveStrategy(budget="low"),
    )
    agent.chat("Summarise what you know about me.")

pip install 'xysq[agent]'

import litellm
from xysq import Xysq
from xysq.integrations.litellm import XysqLiteLLMTools

with Xysq() as client:
    tools = XysqLiteLLMTools(client)

    messages = [
        {
            "role": "system",
            "content": "You have persistent memory tools. Use them proactively.",
        },
        {
            "role": "user",
            "content": "I always want Python examples with type hints.",
        },
    ]

    # LLM decides which tools to call
    response = litellm.completion(
        model="gpt-4o-mini",
        messages=messages,
        tools=tools.definitions,
    )

    # Execute tool calls and collect results
    tool_calls = response.choices[0].message.tool_calls
    if tool_calls:
        results = tools.execute(tool_calls)
        messages.append(response.choices[0].message.model_dump(exclude_none=True))
        messages.extend(results)

        # Continue the conversation
        final = litellm.completion(model="gpt-4o-mini", messages=messages)
        print(final.choices[0].message.content)

pip install 'xysq[claude]'

import anthropic
from xysq import Xysq
from xysq.integrations.anthropic import XysqAnthropicTools

with Xysq() as client:
    tools = XysqAnthropicTools(client)

    claude = anthropic.Anthropic(api_key="sk-ant-...")
    response = claude.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        tools=tools.definitions,
        messages=[{"role": "user", "content": "What do you know about my preferences?"}],
    )

    # Execute tool_use blocks
    for block in response.content:
        if block.type == "tool_use":
            result = tools.execute([block])