Microsoft Agent Framework Integration

pip install neo4j-agent-memory[microsoft-agent]

from neo4j_agent_memory.integrations.microsoft_agent import create_memory_tools

# Create all memory tools bound to a memory instance
tools = create_memory_tools(
    memory,                        # Neo4jMicrosoftMemory instance (required)
    include_gds_tools=True,        # Include GDS algorithm tools (default: True)
)

# Use with agent — framework auto-invokes tools
agent = chat_client.as_agent(
    name="assistant",
    tools=tools,
    context_providers=[memory.context_provider],
)

from neo4j_agent_memory.integrations.microsoft_agent import (
    GDSConfig,
    GDSAlgorithm,
    GDSIntegration,
)

# Configure GDS
gds_config = GDSConfig(
    enabled=True,
    use_pagerank_for_ranking=True,     # Rank entities by importance
    pagerank_weight=0.3,               # Weight for PageRank scores
    use_community_grouping=True,       # Group related entities
    expose_as_tools=[                  # Make available as agent tools
        GDSAlgorithm.SHORTEST_PATH,
        GDSAlgorithm.NODE_SIMILARITY,
        GDSAlgorithm.PAGERANK,
    ],
    fallback_to_basic=True,            # Use Cypher if GDS unavailable
    warn_on_fallback=True,             # Log warning when falling back
)

# Create memory with GDS
memory = Neo4jMicrosoftMemory(
    memory_client=client,
    session_id="user-123",
    gds_config=gds_config,
)

# Use GDS directly
if memory.gds:
    # Find path between entities
    path = await memory.gds.find_shortest_path("Nike", "Running Shoes")

    # Find similar entities
    similar = await memory.gds.find_similar_entities("Nike Air Max", limit=5)

    # Get important entities
    important = await memory.gds.get_central_entities(limit=10)

from neo4j_agent_memory.integrations.microsoft_agent import (
    record_agent_trace,
    get_similar_traces,
    format_traces_for_prompt,
)

# Record agent execution
await record_agent_trace(
    memory=memory,
    messages=[
        {"role": "user", "content": "Find running shoes under $150"},
        {"role": "assistant", "content": "Recommended Nike Pegasus 40 ($130)"},
    ],
    task="Find running shoes under $150",
    tool_calls=[
        {"name": "search_products", "arguments": {"query": "running shoes"}, "result": "..."},
        {"name": "recall_preferences", "arguments": {"category": "brand"}, "result": "Nike"},
    ],
    outcome="success",
    success=True,
)

# Find similar past tasks
traces = await get_similar_traces(
    memory=memory,
    task="Find shoes matching preferences",
    limit=3,
)

# Format for system prompt
experience = format_traces_for_prompt(traces)

## Recent Conversation
[Recent messages relevant to current query]

## Known Preferences
- Brand: Nike
- Budget: Under $150
- Style: Running shoes

## Relevant Entities
- Nike Air Max 90 (Product): Iconic style, $130
- Nike Pegasus 40 (Product): Running shoe, $130

## Past Experience
Similar task: "Find running shoes" - Successfully recommended Pegasus

# Serialize state
provider_state = provider.serialize()
store_state = store.serialize()

# Save to Redis, database, etc.
await redis.set(f"provider:{thread_id}", json.dumps(provider_state))
await redis.set(f"store:{thread_id}", json.dumps(store_state))

# Later: restore state
provider_state = json.loads(await redis.get(f"provider:{thread_id}"))
store_state = json.loads(await redis.get(f"store:{thread_id}"))

# Deserialize (requires fresh MemoryClient)
provider = Neo4jContextProvider.deserialize(provider_state, memory_client=client)
store = Neo4jChatMessageStore.deserialize(store_state, memory_client=client)

import asyncio
from agent_framework import Message
from agent_framework.azure import AzureOpenAIResponsesClient

from neo4j_agent_memory import MemoryClient, MemorySettings
from neo4j_agent_memory.integrations.microsoft_agent import (
    Neo4jMicrosoftMemory,
    GDSConfig,
    GDSAlgorithm,
    create_memory_tools,
    record_agent_trace,
)


async def main():
    settings = MemorySettings(
        neo4j={"uri": "bolt://localhost:7687", "username": "neo4j", "password": "password"},
        embedding={"provider": "openai", "api_key": "sk-..."},
    )

    gds_config = GDSConfig(
        enabled=True,
        expose_as_tools=[GDSAlgorithm.SHORTEST_PATH, GDSAlgorithm.NODE_SIMILARITY],
        fallback_to_basic=True,
    )

    async with MemoryClient(settings) as client:
        # Create memory
        memory = Neo4jMicrosoftMemory(
            memory_client=client,
            session_id="shopping-session-1",
            user_id="user-123",
            gds_config=gds_config,
        )

        # Create chat client
        chat_client = AzureOpenAIResponsesClient(model="gpt-4")

        # Create memory tools bound to the memory instance
        tools = create_memory_tools(memory, include_gds_tools=True)

        # Create agent — tools are callable, framework auto-invokes them
        agent = chat_client.as_agent(
            name="ShoppingAssistant",
            instructions="""You are a helpful shopping assistant.
            Use memory tools to remember preferences and provide personalized recommendations.""",
            tools=tools,
            context_providers=[memory.context_provider],
        )

        # Conversation loop
        while True:
            user_input = input("You: ")
            if user_input.lower() in ("quit", "exit"):
                break

            # Save user message
            await memory.save_message("user", user_input)

            # Run agent — framework auto-invokes tools and returns final response
            response = await agent.run(Message("user", [user_input]))

            # Display response
            if response.text:
                await memory.save_message("assistant", response.text)
                print(f"Assistant: {response.text}")

            # Record trace for learning
            await record_agent_trace(
                memory=memory,
                messages=[
                    {"role": "user", "content": user_input},
                    {"role": "assistant", "content": response.text[:200] if response.text else ""},
                ],
                task=user_input,
                outcome="success",
                success=True,
            )


if __name__ == "__main__":
    asyncio.run(main())