Creating Your First PMCR-O Agent

cd PmcroAgents
dotnet new web -n PmcroAgents.PlannerService
cd PmcroAgents.PlannerService

# Add required packages
dotnet add package Microsoft.Agents.AI
dotnet add package Microsoft.Extensions.AI
dotnet add package OllamaSharp
dotnet add package Grpc.AspNetCore

# Add project references
dotnet add reference ../PmcroAgents.ServiceDefaults
dotnet add reference ../PmcroAgents.Shared

# Add to solution
cd ..
dotnet sln add PmcroAgents.PlannerService

syntax = "proto3";

option csharp_namespace = "PmcroAgents.Shared.Grpc";

package agent;

service AgentService {
  rpc ExecuteTask (AgentRequest) returns (AgentResponse);
}

message AgentRequest {
  string intent = 1;
  string context_json = 2;
}

message AgentResponse {
  string content = 1;
  bool success = 2;
}

using Microsoft.Extensions.AI;
using OllamaSharp;
using PmcroAgents.PlannerService.Services;

var builder = WebApplication.CreateBuilder(args);

// Add ServiceDefaults (OpenTelemetry, health checks, service discovery)
builder.AddServiceDefaults();

// Add gRPC
builder.Services.AddGrpc();

// Configure Ollama client
var ollamaUri = builder.Configuration.GetConnectionString("ollama") 
    ?? "http://localhost:11434";
var modelId = "qwen2.5-coder:7b";

builder.Services.AddHttpClient("ollama", client =>
{
    client.BaseAddress = new Uri(ollamaUri);
    client.Timeout = Timeout.InfiniteTimeSpan;
})
.AddStandardResilienceHandler(options =>
{
    options.AttemptTimeout.Timeout = TimeSpan.FromMinutes(3);
    options.TotalRequestTimeout.Timeout = TimeSpan.FromMinutes(5);
    options.Retry.MaxRetryAttempts = 2;
});

// Register IChatClient
builder.Services.AddSingleton<IChatClient>(sp =>
{
    var httpClient = sp.GetRequiredService<IHttpClientFactory>().CreateClient("ollama");
    var baseClient = new OllamaApiClient(httpClient, modelId);
    
    return new ChatClientBuilder(baseClient)
        .UseFunctionInvocation()
        .Build();
});

var app = builder.Build();

app.MapDefaultEndpoints();
app.MapGrpcService<PlannerAgent>();
app.MapGet("/", () => "Planner Agent - gRPC endpoint available");

app.Run();

using Grpc.Core;
using Microsoft.Extensions.AI;
using PmcroAgents.Shared.Grpc;
using System.Text.Json;

namespace PmcroAgents.PlannerService.Services;

public class PlannerAgent : AgentService.AgentServiceBase
{
    private readonly IChatClient _chatClient;
    private readonly ILogger<PlannerAgent> _logger;

    public PlannerAgent(IChatClient chatClient, ILogger<PlannerAgent> logger)
    {
        _chatClient = chatClient;
        _logger = logger;
    }

    public override async Task<AgentResponse> ExecuteTask(
        AgentRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation("🧭 I AM the Planner. I am analyzing: {Intent}", request.Intent);

        // BIP Identity-First Prompt
        var systemPrompt = @"I AM the Planner.
I TRANSFER complex intent into minimal viable plans.
I EVOLVE through reflection on execution outcomes.

When given an intent, I create a plan with:
- A clear goal statement
- 3-7 actionable steps
- Rationale for each step
- Estimated complexity (low/medium/high)";

        var chatOptions = new ChatOptions
        {
            Temperature = 0.7,
            ResponseFormat = ChatResponseFormat.Json,
            AdditionalProperties = new Dictionary<string, object?>
            {
                ["schema"] = JsonSerializer.Serialize(new
                {
                    type = "object",
                    properties = new
                    {
                        plan = new { type = "string", description = "The implementation plan" },
                        steps = new
                        {
                            type = "array",
                            items = new
                            {
                                type = "object",
                                properties = new
                                {
                                    action = new { type = "string" },
                                    rationale = new { type = "string" }
                                }
                            }
                        },
                        estimated_complexity = new { type = "string", @enum = new[] { "low", "medium", "high" } }
                    },
                    required = new[] { "plan", "steps" }
                })
            }
        };

        var history = new ChatHistory
        {
            new ChatMessage(ChatRole.System, systemPrompt),
            new ChatMessage(ChatRole.User, request.Intent)
        };

        var response = await _chatClient.CompleteChatAsync(history, chatOptions);
        
        _logger.LogInformation("✅ Planner completed. Response: {Response}", response.Content);

        return new AgentResponse
        {
            Content = response.Content,
            Success = true
        };
    }
}

❌ TRADITIONAL: "You are a planner. Generate a plan for the user."
✅ BIP: "I AM the Planner. I TRANSFER complex intent into minimal viable plans."

// Test client (create a simple console app)
using Grpc.Net.Client;
using PmcroAgents.Shared.Grpc;

var channel = GrpcChannel.ForAddress("http://localhost:5001");
var client = new AgentService.AgentServiceClient(channel);

var request = new AgentRequest
{
    Intent = "Build a PMCR-O agent service with PostgreSQL knowledge vault for RAG"
};

var response = await client.ExecuteTaskAsync(request);
Console.WriteLine(response.Content);

{
  "plan": "Create a PMCR-O agent service with PostgreSQL knowledge vault for RAG",
  "steps": [
    {
      "action": "Set up .NET 10 service project with Aspire orchestration",
      "rationale": "Aspire provides service discovery and observability for agent services"
    },
    {
      "action": "Configure PostgreSQL with pgvector extension for vector embeddings",
      "rationale": "RAG requires vector similarity search for knowledge retrieval"
    },
    {
      "action": "Implement Entity Framework Core DbContext with vector support",
      "rationale": "EF Core provides type-safe database access with Npgsql vector extensions"
    },
    {
      "action": "Create knowledge service with embedding storage and retrieval",
      "rationale": "Agents need persistent memory for cognitive trails and learned patterns"
    }
  ],
  "estimated_complexity": "medium"
}