tl;dr

• Microsoft Agent Framework implements RAG via TextSearchProvider (an AIContextProvider) and a Semantic Kernel bridge to many vector stores.
• Two retrieval modes: BeforeAIInvoke (automatic injection) and OnDemandFunctionCalling (agent calls search as a tool).
• Recommended starting defaults: top_k = 3–5, chunk size ≈ 500–1,000 characters with 10–20% overlap, and prefer OnDemandFunctionCalling for cost/latency control.
• Key production concerns: chunking, metadata for citations, latency and cost management, freshness, security and telemetry.

Key terms

• AIContextProvider: a component that supplies contextual data to an agent before the model is invoked. TextSearchProvider implements retrieval as an AIContextProvider.
• Tool / Function calling: exposes actions (search, API calls) as callable functions the agent can invoke on demand during reasoning. The TextSearchProvider can be advertised as such (OnDemandFunctionCalling).
• VectorStore / TextSearchStore: VectorStore holds embeddings and indexes; TextSearchStore is a convenience schema for text chunks + metadata built on a VectorStore.

Core components

• VectorStore: stores embeddings + metadata. Backends supported via Semantic Kernel include InMemory, Qdrant, Pinecone, Redis, Weaviate, Azure AI Search, etc.
• TextSearchStore: wraps a VectorStore with a text‑centric schema (collectionName, namespace, vector dimensions, chunk metadata).
• TextSearchProvider: the AIContextProvider that performs searches and either injects results or exposes search as a callable tool.
• Kernel bridge: converts Semantic Kernel search functions into Agent Framework tools so the same agent logic works across backends.
• Agent / AgentThread: the runtime that combines user messages, context providers, tools, and the LLM to produce grounded responses.

How RAG is implemented — simple flow
1) Index your docs into a VectorStore:

• Generate embeddings (Azure OpenAI, OpenAI, etc.) and store vectors with metadata (source URL, chunk id, section).
  2) Wrap the VectorStore in a TextSearchStore (choose collectionName, namespaces).
  3) Create a TextSearchProvider backed by the TextSearchStore and add it to the agent thread’s AIContextProviders.
  4) Choose SearchTime:
• BeforeAIInvoke (default): run searches automatically before each model call and inject the top results into the prompt.
• OnDemandFunctionCalling: advertise search as a callable tool and let the agent call it while reasoning.
  5) Run the agent: retrieved text is combined with the prompt and sent to the LLM; results can include source metadata for inline citations.

Injection mechanics — what actually gets passed to the model

• In BeforeAIInvoke mode, the provider runs a vector search (by default top_k hits) and concatenates the retrieved chunks into the agent’s context. That context is typically appended as extra system/assistant content and is subject to truncation/prioritization to respect the model’s context window.
• In OnDemandFunctionCalling mode, the search appears as a callable tool; the LLM receives the tool’s output (chunks + metadata) only when the agent invokes the tool.
• Retrieved results include metadata (source URL, document id, chunk id, score). Use that metadata for citations and audit trails.
• You control ranking limits and filtering via TextSearchProviderOptions (top_k, namespaces, recency filters, message memory limits).

Defaults and practical parameter guidance

• top_k (number of chunks returned): start with 3–5. More adds context but increases token use and noise.
• Chunk size: aim for 500–1,000 characters per chunk (roughly 75–200 tokens). This balances retrieval granularity and coherent passages. If you prefer token‑based chunks, 200–500 tokens is a reasonable upper bound for longer passages.
• Overlap: 10–20% overlap between adjacent chunks helps prevent losing relevant sentence boundaries.
• Relevance filtering: use namespace/collectionName to scope queries (multi‑tenant or multi‑corpus setups).
• Embedding model: choose a semantic embedding suitable for your domain; embedding quality directly affects retrieval relevance.

BeforeAIInvoke vs OnDemandFunctionCalling — choose by use case

• BeforeAIInvoke (automatic):
• Best when almost every user query must be grounded (e.g., compliance answers).
• Simpler to reason about: search runs, results are always available to the model.
• Downsides: higher cost and possible token bloat.
• Trace: user query -> provider runs search -> top_k chunks injected -> model call -> response.
• OnDemandFunctionCalling (agentic/tool-based):
• Best when many queries are casual or do not need grounding, and you want the agent to decide when to fetch data.
• Enables multi‑step reasoning (agent thinks, calls search, examines results, calls other tools, returns final).
• Lower baseline cost and conditional latency.
• Trace: user query -> agent begins reasoning -> decides to call Search tool -> search returns chunks -> agent may call another tool or ask follow-up -> final model call -> response.

Example: a multi-step agentic sequence (conceptual)
1) User: “How do I roll back build 1.2.3?”
2) Agent (thinking): Not sure. Calls Search tool with query “roll back build 1.2.3 runbook”.
3) Search returns runbook chunks A, B (with source URLs).
4) Agent inspects chunks, calls a “Validate-Runbook” tool to confirm commands are safe.
5) Agent composes final answer quoting steps and adds “[source: Runbook / sectionX | URL]” inline for each step.

Prompt and output formatting — keep answers auditable

• When injecting retrieved content, format chunks with clear attribution. Example snippet used in the prompt:
  [Retrieved 1/3] Title: “Rollback Procedure” — Source: https://contoso/docs/runbook#sectionX
  “Step 1: … Step 2: …” (chunk id: abc123)
• When returning a final answer, include inline citations:
  “To roll back build 1.2.3, follow steps 1–3 (see Runbook: https://contoso/docs/runbook#sectionX).”
• If using OnDemandFunctionCalling, have the tool return structured metadata (title, url, chunk_id, score) so the agent can produce precise citations.

Code outline (C#) — on‑demand search example (conceptual)

// 1) Create embedding generator (IEmbeddingGenerator), vector store and TextSearchStore
var embeddingGenerator = /* AzureOpenAI embedding client */;
var vectorStore = new InMemoryVectorStore(new() { EmbeddingGenerator = embeddingGenerator });
using var textSearchStore = new TextSearchStore(vectorStore, collectionName: “Docs”, vectorDimensions: 1536);

// 2) Create TextSearchProvider with on‑demand behavior
var options = new TextSearchProviderOptions { SearchTime = TextSearchProviderOptions.TextSearchBehavior.OnDemandFunctionCalling, TopK = 4 };
var textSearchProvider = new TextSearchProvider(textSearchStore, options);

// 3) Attach to agent thread
var agentThread = new ChatHistoryAgentThread();
agentThread.AIContextProviders.Add(textSearchProvider);

// 4) Invoke the agent — the agent may call the search tool during reasoning
var response = await agent.InvokeAsync(“How do I roll back build 1.2.3?”, agentThread).FirstAsync();
// response includes final answer; the framework supplies tool outputs when the agent invoked the search tool

Production checklist and operational considerations

• Latency: measure search latency and embedding latency; cache frequent queries; prefer on‑demand to avoid unnecessary embedding at request time.
• Cost: monitor embedding and LLM call spend; use top_k and chunk limits strategically; cache and reuse embeddings where possible.
• Freshness: plan an ingestion cadence and a strategy for reindexing changed documents.
• Chunking/metadata: store rich metadata (source URL, section, timestamp) to make citations reliable.
• Hallucination & prompt injection: sanitize retrieved text, require provenance for critical facts, and apply verification steps for high‑risk actions.
• Scaling: choose a production VectorStore that supports the throughput and replication you need (Qdrant, Pinecone, Redis, Azure AI Search).
• Security & permissions: treat vector stores and connectors as sensitive; enforce least privilege and secure credentials for connectors (Oracle, SQL, etc.).
• Telemetry & observability: capture search latency, top_k, cache hit rate, tool call counts, and a hallucination/error metric (mismatch between cited source and assertion). Log search queries and returned metadata for auditing.
• Limitations: retrieval quality depends on embeddings and chunk strategy; RAG does not replace the need for verification for time‑sensitive facts unless you keep the index fresh.

Where to learn more

• Microsoft Learn: RAG | Agent Framework
• Microsoft Learn: Adding RAG to Semantic Kernel Agents
• Agent Framework samples (06.RAGs)
• Previous articles on RAG listed here.

~2 hours a day for 16 weeks + 3 projects. Excellent program.

Understanding GitHub Copilot and Microsoft Agent Framework

What is GitHub Copilot?

GitHub Copilot is an AI-powered code completion tool developed by GitHub in collaboration with OpenAI. It leverages machine learning models trained on a vast corpus of code to assist developers by suggesting code snippets, functions, and even entire algorithms as they write. Copilot aims to enhance the coding experience by reducing the time spent on repetitive tasks and providing intelligent suggestions based on context.

What is the Microsoft Agent Framework?

The Microsoft Agent Framework (MAF) is a platform designed for building intelligent agents that can interact with users and perform tasks autonomously. MAF provides a robust architecture that supports extensibility, observability, and middleware capabilities, making it an ideal choice for developing production-ready agents. With MAF, developers can create agents that can integrate with various services, manage workflows, and provide insights into their operations. For much more on this see the posts listed here.

Key Features and Innovations

1. Agentic Harness

The integration of GitHub Copilot with MAF introduces an “Agentic Harness,” which is a coding-focused framework that supports various approaches to agent development. This harness enables:

• Planning: Agents can plan their actions based on user input and context.
• Tool Execution: Agents can execute specific tools or commands as part of their operations.
• Shell Access: Agents can interact with the system shell to perform tasks directly.
• File Manipulation: Agents can read, write, and modify files as needed.
• URL Retrieval: Agents can fetch data from the web, enhancing their capabilities.

2. Extensibility

One of the standout features of MAF is its extensibility. Developers can integrate multiple agent providers, including GitHub Copilot, into their applications. This flexibility allows for the creation of customized agents that can leverage the strengths of different tools and services, resulting in a more powerful and adaptable solution.

3. Observability and Middleware

MAF comes equipped with built-in observability features that enable developers to monitor and manage agent behavior in real-time. This is crucial for ensuring that agents operate as intended, especially in production environments. Middleware support allows for the integration of additional functionalities, such as logging, error handling, and performance monitoring, further enhancing the robustness of the agents.

Real-World Use Cases

The integration of GitHub Copilot with MAF opens up many possibilities for developers. Here are some compelling use cases:

Automated Code Review

Developers can create agents that automatically review code changes, suggest improvements, and execute tests. By leveraging Copilot’s coding capabilities, these agents can provide insightful feedback, helping teams maintain high code quality and adhere to best practices.

DevOps Automation

Integrating Copilot with MAF can significantly streamline Continuous Integration/Continuous Deployment (CI/CD) pipelines. Agents can automate deployment tasks, monitor system health, and respond to incidents, allowing DevOps teams to focus on strategic initiatives rather than routine operations.

Intelligent Chatbots

By utilizing the capabilities of both GitHub Copilot and MAF, developers can build intelligent chatbots that assist users in various tasks, from answering queries to providing recommendations. These chatbots can learn from interactions and improve their responses over time, enhancing user satisfaction.

Data Processing and Analysis

Agents can be designed to process and analyze large datasets, generating insights and visualizations. By automating data-related tasks, organizations can make informed decisions faster and more efficiently.

Getting Started with GitHub Copilot and MAF

To harness the power of GitHub Copilot with the Microsoft Agent Framework, you need to set up your development environment and install the necessary SDKs. Below are the steps to get started.

Installation

For .NET

To integrate GitHub Copilot with MAF in a .NET environment, you can use the following commands:

dotnet add package GitHub.Copilot.SDK
dotnet add package Microsoft.Agents.AI.GitHub.Copilot --prerelease

For Python

If you are working in a Python environment, you can install the required packages using pip:

pip install copilot-sdk agent-framework-github-copilot

Setting Up Your Development Environment

Once you have installed the necessary SDKs, you can start building your agents. Below is example code for both C# and Python to demonstrate how to create a simple agent that interacts with GitHub Copilot.

Example Code

C# Example

Here’s a basic example of how to create an agent using C#:

using GitHub.Copilot.SDK;
using Microsoft.Agents.AI;

class Program
{
    static async Task Main(string[] args)
    {
        await using CopilotClient copilotClient = new();
        await copilotClient.StartAsync();
        AIAgent agent = copilotClient.AsAIAgent();
        Console.WriteLine(await agent.RunAsync("What is Microsoft Agent Framework?"));
    }
}

Python Example

Below is a similar example using Python:

import asyncio
from agent_framework.github import GitHubCopilotAgent

async def basic_example():
    agent = GitHubCopilotAgent(
        default_options={"instructions": "You are a helpful assistant."},
    )
    async with agent:
        result = await agent.run("What is Microsoft Agent Framework?")
        print(result)

asyncio.run(basic_example())

Conclusion

The integration of GitHub Copilot with the Microsoft Agent Framework provides a robust platform for developing intelligent agents capable of automating various tasks in software development. By leveraging the capabilities of both tools, developers can create agents that enhance productivity and streamline workflows. The potential applications are vast, ranging from automated code reviews to DevOps automation and intelligent chatbots.

For more detailed information, see: Microsoft Agent Framework documentation.

Much more on this to come.

Understanding Microsoft Agent Framework (MAF)

Before diving into the deployment process, it’s essential to understand what the Microsoft Agent Framework is and how it can benefit your applications. MAF is designed to facilitate the development of intelligent agents that can perform tasks, respond to user queries, and integrate with various services. These agents can be deployed in a cloud environment, allowing for scalability and ease of management. For much more on Microsoft Agent Framework see the table of contents here.

Overview of Foundry

Microsoft Foundry is a cloud-based platform that provides a managed environment for deploying and running applications. It abstracts the complexities of infrastructure management, allowing developers to focus on building and deploying their applications. Foundry supports various deployment models, including containerized applications, making it an ideal choice for deploying MAF applications. In this blog post I’ll show how to use containers for deployment. In an upcoming blog post I’ll show a simpler approach.

Key Steps for Deployment

Deploying a MAF application to Foundry using containers involves several key steps. Each step is crucial for ensuring that your application is packaged correctly, deployed efficiently, and registered with the Foundry Agent Service. Below is a detailed breakdown of the deployment process.

Step 1: Build and Package Your Agent

The first step in deploying your MAF application is to build and package it into a Docker container. This process involves creating a Dockerfile that defines how your application will be built and run within a container.

Creating a Dockerfile

A Dockerfile is a text document that contains all the commands needed to assemble an image. Here’s a simple example of a Dockerfile for a MAF application:

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
COPY . .
ENTRYPOINT ["dotnet", "YourApp.dll"]

In this example:

• The base image is set to the ASP.NET runtime.
• The working directory is defined as /app.
• The application files are copied into the container.
• The entry point is specified to run the application.

Local Testing

Before deploying your application, it’s crucial to test it locally. This ensures that your application behaves as expected and that all endpoints are functioning correctly. You can use the protocol library to validate the endpoints and ensure that your application is ready for deployment.

Step 2: Push to Azure Container Registry

Once your application is packaged into a Docker container, the next step is to push the container image to Azure Container Registry (ACR). ACR is a managed Docker container registry that allows you to store and manage your container images.

Using Azure Developer CLI

To push your container image to ACR, you can use the Azure Developer CLI (azd). Here’s the command to push your container image:

azd container push your-container-image

This command uploads your image to ACR, making it available for deployment.

Step 3: Register the Agent with Foundry

After pushing your container image to ACR, the next step is to register your agent with the Foundry Agent Service. This step provisions the necessary infrastructure and creates a dedicated identity for your agent.

Creating an Agent Version

To register your agent, you can use the following command:

azd foundry agent create --image your-container-image

This command creates an agent version in Foundry using the image you just pushed. It’s important to ensure that the image is accessible and correctly configured.

Step 4: Poll for Status

Once you have registered your agent, poll for the status until it reaches active. This step ensures that your agent is fully provisioned and ready to handle requests.

Step 5: Invoke Your Agent

After your agent is active, you can start sending requests to its dedicated endpoint. This allows you to interact with your agent and utilize its capabilities.

Example Invocation

Here’s an example of how to invoke your agent using Python:

import requests

response = requests.post("https://your-agent-endpoint", json={"input": "Where is Seattle?"})
print(response.json())

The request sends a JSON payload to the agent, and the response is printed to the console.

Key Considerations

When deploying a MAF application to Foundry, there are several key considerations to keep in mind:

Local Testing

Before deploying, ensure that your agent works locally. The container should serve the same endpoints locally as it does in production. This step will identify any issues before deployment.

Managed Infrastructure

One of the significant advantages of using Foundry is that it provides a managed environment. This means you don’t have to worry about the underlying infrastructure. Each agent gets its own dedicated endpoint and identity, simplifying the deployment process.

Multi-Agent Workflows

Foundry supports orchestrating complex workflows using multiple agents.

Conclusion

Deploying a Microsoft Agent Framework application to Foundry is a structured process that involves building, packaging, and registering your application. By following the steps outlined in this guide, you can ensure that your MAF application is deployed efficiently and effectively, leveraging the capabilities of the Foundry platform.

Additional Resources

For further reading see Deploy a hosted agent – Microsoft Learn

Understanding Token Usage

Before diving into the techniques, it’s essential to understand what token usage entails. In the context of AI models, a token can represent a word, part of a word, or even punctuation. Each interaction with the model consumes tokens, both for the input provided and the output generated. Therefore, optimizing token usage is crucial for maintaining efficiency and controlling costs, especially in applications with high interaction volumes, such as chatbots and multi-agent systems.

Key Techniques for Minimizing Token Usage

1. Token Management

One of the most straightforward methods to control token usage is through effective token management. By setting a maximum number of tokens for responses, developers can prevent excessive consumption and ensure that outputs remain concise and relevant.

Example in C#:

var response = await agent.GenerateResponseAsync(input, maxTokens: 100);

In this example, the response is limited to 100 tokens, which helps maintain brevity and relevance.

2. Context Management

Context management is another critical area where developers can minimize token usage. Instead of sending the entire conversation history to the model, it is more efficient to retain only the most relevant exchanges. Typicallly this comes down to retaining only the most recent exchanges. This approach not only reduces the number of tokens sent but also enhances the model’s focus on pertinent information.

Example in Python:

context = [message for message in conversation_history[-5:]]  # Keep last 5 messages
response = agent.generate_response(input, context=context)

By limiting the context to the last five messages, developers can significantly reduce token consumption while still providing the model with enough information to generate a relevant response.

3. Efficient History Management

When interacting with the model, it is essential to avoid resending large outputs or logs with every API call. Instead, developers should focus on sending only the essential context. Utilizing new threads for stateless interactions can also help prevent the unnecessary transmission of long histories.

Example in C#:

var newThreadId = Guid.NewGuid().ToString();
var response = await agent.GenerateResponseAsync(input, threadId: newThreadId);

This method ensures that each interaction is treated independently, minimizing the amount of historical data sent with each request.

4. Lightweight Summarization

To maintain continuity in conversations while reducing payload size, developers can implement lightweight summarization techniques. By periodically summarizing previous interactions, the summary can be sent as context, which helps keep the conversation relevant without inflating token usage.

5. Token-Optimized Object Notation (TOON)

Token-Optimized Object Notation (TOON) is a powerful technique for structuring data in a way that achieves high compression ratios, with some reports indicating reductions of up to 98% for certain payloads. This method is particularly useful for applications that require the transmission of structured data. This is typically done by the framework — it is very unusual to try to do this manually.

6. Server-Side Computation

Another effective strategy for minimizing token usage is to move computation tasks to the server rather than performing them within the context of the model. By offloading these tasks, developers can reduce the amount of data sent to the model, thereby lowering token consumption.

Measuring Token Usage

To effectively manage token usage, developers must also implement robust measurement techniques. Here are some strategies for measuring token usage within the Microsoft Agent Framework:

Metrics Integration

Utilizing built-in metrics from the Microsoft Agent Framework allows developers to monitor input and output tokens, estimated costs, and latency. This data is invaluable for optimizing performance and identifying areas for improvement.

Breakdown Analysis

Conducting a breakdown analysis of token usage across different stages—such as retrieval, planning, and execution—can help developers pinpoint where savings can be made. By understanding which stages consume the most tokens, developers can focus their optimization efforts more effectively.

Real-World Use Cases

The techniques discussed above can be applied across various real-world scenarios, leading to significant improvements in efficiency and cost-effectiveness.

Chatbots

In chatbot applications, implementing these techniques can lead to substantial cost savings and enhanced performance, particularly in high-traffic environments. By managing token usage effectively, chatbots can handle more interactions without incurring excessive costs.

Multi-Agent Systems

In systems with multiple agents, distributing tasks among specialized agents can reduce redundant context passing and lower latency. This approach not only minimizes token usage but also enhances the overall responsiveness of the system.

========== TOKEN USAGE FOR FIRST DRAFT OF THIS BLOG POST ==========
Input tokens: 4180
Output tokens: 1838
Reasoning tokens: 0
Total tokens: 6018

A Graph Database

In the era of big data, the way we store and manage information has evolved significantly. Traditional relational databases, while effective for many applications, often struggle with complex data relationships. Enter Neo4j, a leading graph database that allows users to model and query data in a way that reflects real-world relationships. This guide will walk you through the essentials of using Neo4j, from installation to practical applications, ensuring you have a solid foundation to leverage this powerful tool.

Understanding Neo4j

What is a Graph Database?

At its core, a graph database is designed to represent and store data in the form of nodes and relationships. In Neo4j:

• Nodes represent entities (e.g., people, products, locations).
• Relationships define how these entities are connected (e.g., friendships, purchases, and geographical proximity).

This structure makes graph databases particularly well-suited for applications that require complex querying of interconnected data, such as social networks, recommendation systems, and fraud detection.

The Cypher Query Language

Neo4j utilizes Cypher, a declarative query language specifically designed for graph data. Cypher allows users to express what data they want to retrieve without needing to specify how to get it. This makes it intuitive and powerful for querying complex relationships.

Getting Started with Neo4j

Installation

To begin using Neo4j, you need to install it on your machine. There are two primary methods for installation:

1. Download the Neo4j Community Edition:

• Visit the official Neo4j website and download the Community Edition, which is free and open-source.

1. Using Docker:

• If you prefer containerization, you can easily run Neo4j using Docker. Open your terminal and execute the following commands:
  bash docker pull neo4j docker run -p7474:7474 -p7687:7687 neo4j
• This command pulls the latest Neo4j image and runs it, exposing the necessary ports for web access and Bolt protocol.

Using Neo4j Sandbox

For those who are new to Neo4j or want to experiment without installation, the Neo4j Sandbox is an excellent resource. It provides a cloud-based environment with sample datasets and guided tutorials, allowing you to explore Neo4j’s capabilities without any setup.

Basic Cypher Commands

Once you have Neo4j up and running, you can start interacting with it using Cypher. Here are some fundamental commands to get you started:

Creating Nodes

To create a new node, you can use the following command:

CREATE (n:Person {name: 'Alice', age: 30})

This command creates a node labeled Person with properties name and age.

Creating Relationships

To establish a relationship between two nodes, you can use the MATCH and CREATE commands:

MATCH (a:Person {name: 'Alice'})
CREATE (a)-[:FRIENDS_WITH]->(b:Person {name: 'Bob'})

This command finds the node representing Alice and creates a FRIENDS_WITH relationship to a new node representing Bob.

Querying Data

To retrieve data from your graph, you can use the MATCH command:

MATCH (n:Person) RETURN n

This command returns all nodes labeled Person, allowing you to see the data you’ve created.

Real-World Use Cases

Neo4j’s graph structure lends itself to various applications across different industries. Here are some notable use cases:

1. Social Networks

Graph databases excel at modeling relationships, making them ideal for social networking applications. You can easily represent users, their connections, and interactions, enabling features like friend suggestions and relationship analysis.

2. Recommendation Systems

By analyzing user behavior and preferences, Neo4j can power recommendation engines. For instance, you can suggest products based on users’ past purchases or their friends’ activities, enhancing user engagement and satisfaction.

3. Fraud Detection

In financial services, Neo4j can help identify fraudulent activities by analyzing connections between transactions. By visualizing relationships, you can uncover suspicious patterns that may indicate fraud, allowing for timely intervention.

Resources for Learning Neo4j

To deepen your understanding of Neo4j and its capabilities, consider exploring the following resources:

Tutorials

• TutorialsPoint Neo4j Tutorial: A comprehensive guide that covers everything from the basics to advanced topics in Neo4j.
• DataCamp Neo4j Tutorial: This tutorial focuses on using Neo4j with Python, including data ingestion and querying techniques.

Video Tutorials

• Introduction to Neo4j: A beginner-friendly video that covers installation and basic usage, perfect for visual learners.

Conclusion

Neo4j is a powerful graph database that offers a unique approach to managing and querying complex data relationships. As you saw in the previous blog post, it is the framework that Agent Memory for .NET leverages.

Overview of Agent Memory for .NET

Agent Memory for .NET is a sophisticated solution that allows AI agents to store and recall information across sessions. By utilizing a graph database structure, that is, one that organizes data as nodes, edges and properties, it enables agents to create a rich knowledge graph that captures entities, relationships, and interactions over time.

Key Features and Innovations

Types of Memory:

• Short-term Memory: This component captures the immediate context of conversations, allowing agents to respond appropriately to ongoing dialogues.
• Long-term Memory: This aspect stores a comprehensive knowledge graph that includes entities and relationships, enabling agents to recall past interactions and provide personalized responses.
• Reasoning Memory: By recording the agent’s actions and decisions, this memory type enhances the agent’s ability to make informed decisions in future interactions.

Time-aware Memory: One of the standout features of Agent Memory for .NET is its support for bitemporal recall. Bitemporal recall is the ability of a data system to track and query information across two distinct timelines — in this case valid time (when the fact was true in the real world) and transaction time (when the fact was recorded in the Database). This allows agents to answer questions based on both past beliefs and current knowledge, providing a more nuanced understanding of user queries.

Integration: The framework is designed to be compatible with the Microsoft Agent Framework and other .NET applications. This seamless integration makes it easy for developers to incorporate Agent Memory into existing systems without significant overhead.

Graph-Native Structure: By leveraging Neo4j’s graph database capabilities, Agent Memory for .NET can store and query memory efficiently. This structure allows for complex relationships and interactions to be represented in a way that is both intuitive and powerful.

Implementation: Getting Started with Agent Memory for .NET

To illustrate how to set up Agent Memory for .NET, let’s walk through a simple code example. This demonstrates how to initialize the memory store, store a memory, and retrieve it.

Prerequisites

Before you begin, ensure you have the following:

• .NET SDK installed on your machine.
• A running instance of Neo4j. You can download and install Neo4j from the official website.

Code Example

Here’s a straightforward example of how to set up Agent Memory for .NET using Neo4j:

using Neo4j.Driver;
using AgentMemory;

class Program
{
    static async Task Main(string[] args)
    {
        // Initialize Neo4j Driver
        var driver = GraphDatabase.Driver("bolt://localhost:7687", AuthTokens.Basic("neo4j", "password"));

        // Create a new memory store
        var memoryStore = new MemoryStore(driver);

        // Store a memory
        await memoryStore.StoreMemory("user123", "What is the capital of France?", "Paris");

        // Retrieve a memory
        var response = await memoryStore.RetrieveMemory("user123", "What is the capital of France?");
        Console.WriteLine(response); // Outputs: Paris
    }
}

Explanation of the Code

1. Initialize Neo4j Driver: The first step is to create a connection to your Neo4j database using the GraphDatabase.Driver method. Replace the connection string and authentication details with your own.
2. Create a Memory Store: An instance of MemoryStore is created, which will handle the storage and retrieval of memories.
3. Store a Memory: The StoreMemory method is called to save a memory associated with a specific user. In this case, we store the question “What is the capital of France?” along with the answer “Paris”.
4. Retrieve a Memory: Finally, we retrieve the stored memory using the RetrieveMemory method and print the response to the console.

By leveraging the power of Neo4j, Agent Memory for .NET provides a solution for enhancing applications with persistent memory.

For more information and resources, see the Agent Memory for .NET GitHub Repository and the Neo4j Blog on Agent Memory. Also see:  Microsoft Agent Framework Neo4J and Agent With Memory

What is Microsoft Agent Framework?

To quickly review, Microsoft Agent Framework is a development framework designed specifically for creating AI agents. These agents are capable of interacting with various services and data sources, making them versatile tools for developers. The framework provides a rich set of tools and libraries that enable developers to build intelligent applications that can automate tasks, respond to user queries, and integrate with other systems.

Key Features of Microsoft Agent Framework

1. Development Tools: The framework includes a variety of libraries and APIs that simplify the process of building AI agents. Developers can leverage these tools to create agents that can understand natural language, process data, and perform complex tasks.
2. Integration Capabilities: The framework is designed to work with various data sources and services, allowing developers to create agents that can pull information from multiple platforms and provide comprehensive responses to user queries.
3. Flexibility: Developers can use the Microsoft Agent Framework alongside other frameworks, such as the OpenAI Agents SDK, to create a wide range of applications, from simple chatbots to complex AI-driven solutions.

For much more on Microsoft Agent Framework and agentics in general see the blog posts beginning here.

What is Microsoft Foundry?

Microsoft Foundry is a managed platform that provides a comprehensive environment for building, deploying, and scaling AI applications. It offers a suite of tools and services that enable developers to utilize various AI models and frameworks, making it easier to create sophisticated applications.

Key Features of Microsoft Foundry

1. Managed Environment: Foundry provides a fully managed environment, which means developers can focus on building their applications without worrying about the underlying infrastructure. This allows for faster development cycles and easier scaling.
2. AI Model Integration: Foundry supports a wide range of AI models and tools, enabling developers to leverage the latest advancements in AI technology. This integration allows for the creation of more intelligent and capable agents.
3. Governance and Observability: Foundry includes features that help organizations maintain compliance with regulations, making it particularly beneficial for industries that require strict governance, such as finance and healthcare.

The Relationship Between Microsoft Agent Framework and Microsoft Foundry

The relationship between the Microsoft Agent Framework and Microsoft Foundry is one of synergy and integration. Together, they provide a robust environment for developing AI agents that can handle complex tasks and workflows. Here are some key aspects of their relationship:

1. Integration of Services

The Foundry Agent Service acts as a bridge between the Microsoft Agent Framework and various data sources and other agents. This integration enables seamless communication and data exchange, which is crucial for developing multi-agent workflows that can manage complex business processes.

Additionally, the Responses API serves as a single entry point for accessing Foundry models and tools. This allows developers to build agents using the Agent Framework while leveraging the capabilities of Foundry, creating a more cohesive development experience.

2. Multi-Agent Workflows

Both Foundry and Microsoft Agent Framework support the creation of multi-agent workflows. This feature allows developers to orchestrate complex, multi-step processes, enhancing the capabilities of AI applications. By enabling multiple agents to work together, organizations can automate intricate workflows that would be challenging to manage with a single agent.

3. Identity and Security

Security is a paramount concern in the development of AI applications. The Microsoft Agent Framework utilizes Microsoft Entra ID for managing agent identities, ensuring secure authentication and authorization. With Foundry you get this and many other infrastructure features out of the box.

4. Development Flexibility

The combination of the Microsoft Agent Framework and Microsoft Foundry offers developers significant flexibility in how they create agents. They can choose to build agents using the Microsoft Agent Framework and have them hosted in Foundry, or they can create AI applications directly with Foundry. This flexibility is essential for meeting the diverse needs of businesses and organizations.

For more on this, be sure to watch my video interview of Bruno Capuano and Jon Galloway, both of Microsoft, where, among other things, Bruno demonstrates how easy it is to have Foundry host a Microsoft Agent Framework application.

Note: Microsoft strongly suggests using secrets and not putting these values in config.json

What is config.json?

The config.json file is a widely used configuration file format in many programming environments, particularly in JavaScript and .NET applications. It serves as a simple way to store application settings, such as API endpoints, feature flags, and other non-sensitive configurations. The structure of a config.json file is straightforward, making it easy for developers to read and modify.

Example of config.json

{
  "ApiUrl": "https://api.example.com",
  "FeatureFlag": true
}

Advantages of Using config.json

1. Simplicity and Accessibility: One of the primary advantages of using config.json is its simplicity. Developers can easily read and modify the file, making it an excellent choice for local development and testing environments. This ease of access allows for rapid iteration and debugging.
2. Version Control: Configuration files can be included in version control systems like Git. This feature is beneficial for tracking changes over time, allowing teams to collaborate effectively and maintain a history of configuration changes.
   
   Note, if you have secret values (such as keys) you do not want them in version control. One solution is to add them to your .gitignore file. A better solution is not to have them in config.json in the first place.
   
3. No Additional Setup Required: Unlike secrets management systems, which may require additional setup and configuration, using config.json typically involves minimal overhead. Developers can start using it right away without needing to integrate with external services.

Disadvantages of Using config.json

1. Security Risks: The most significant drawback of using config.json is its lack of security for sensitive data. If sensitive information, such as passwords or API keys, is stored in this file, it can be easily accessed by anyone with access to the codebase. This poses a substantial risk, especially in production environments.
2. Accidental Exposure: Including config.json in version control can lead to accidental exposure of sensitive data. Developers must be diligent about ensuring that sensitive information is excluded from version control, which can be challenging.
3. Limited to Non-Sensitive Data: While config.json is suitable for general configuration, it is not designed for managing sensitive information securely. Developers must find alternative methods for handling sensitive data, which can complicate the development process.

Secrets Management in Microsoft Agent Framework

What is Secrets Management?

The Microsoft Agent Framework provides a robust secrets management system designed to securely manage sensitive information such as credentials, API keys, and other secrets. This system is particularly useful for applications deployed in production environments where security is paramount.

Example of Secrets Management

Using Azure Key Vault, developers can securely store and retrieve secrets. Here’s a simple example of how to access a secret using the Azure SDK:

var secretClient = new SecretClient(new Uri("https://<your-key-vault-name>.vault.azure.net/"), new DefaultAzureCredential());
KeyVaultSecret secret = await secretClient.GetSecretAsync("MySecret");
string secretValue = secret.Value;

Advantages of Using Secrets Management

1. Enhanced Security: The primary advantage of using a secrets management system is its built-in security features. Secrets are encrypted and access-controlled, ensuring that sensitive data is not exposed in the codebase. This level of security is essential for protecting sensitive information in production environments.
2. Centralized Management: Secrets management systems like Azure Key Vault allow for centralized management of secrets across multiple applications. This centralization simplifies the process of updating and rotating secrets, reducing the risk of outdated or compromised credentials.
3. Integration with Azure Services: The Microsoft Agent Framework’s secrets management seamlessly integrates with other Azure services, providing a cohesive environment for managing application secrets. This integration enhances the overall security posture of applications deployed in the Azure ecosystem.

Disadvantages of Using Secrets Management

1. Complexity: Implementing a secrets management system can introduce additional complexity in setup and management compared to using a simple configuration file. Developers must familiarize themselves with the secrets management system and its APIs, which may require additional time and resources.
2. Cost: Depending on the chosen secrets management solution, there may be associated costs. For example, using Azure Key Vault incurs charges based on the number of operations performed and the amount of data stored. Organizations must weigh these costs against the benefits of enhanced security.
3. Learning Curve: For teams unfamiliar with secrets management practices, there may be a learning curve involved in adopting a new system. Training and documentation may be necessary to ensure that all team members understand how to use the system effectively.

Key Trade-offs

When deciding between config.json and secrets management in the Microsoft Agent Framework, developers must consider several key trade-offs:

1. Security vs. Convenience: Using config.json is convenient for non-sensitive configurations but poses security risks for sensitive data. In contrast, the Microsoft Agent Framework’s secrets management is secure but may require more setup and management effort.
2. Development vs. Production: config.json is often more suitable for development environments, where rapid iteration is essential. However, for production environments, where security is a priority, leveraging secrets management is advisable.
3. Version Control: Configuration files can be versioned easily, allowing for tracking changes over time. However, secrets should never be included in version control to prevent accidental exposure, necessitating a different approach for managing sensitive data.

Conclusion

Choosing between config.json and secrets management in the Microsoft Agent Framework ultimately depends on the specific needs of your application. For general configuration values that do not involve sensitive information, config.json remains a practical choice, provided that developers are diligent about handling sensitive data appropriately. However, for applications that require the management of sensitive information, leveraging the secrets management capabilities of the Microsoft Agent Framework is advisable to ensure security and compliance.

In summary, understanding the differences and trade-offs between these two approaches is crucial for developers aiming to build secure and efficient applications. By carefully considering the specific requirements of your project, you can make an informed decision that balances convenience, security, and maintainability.

Bzzzz Still your turn.