Migrating from LangChain to PMCR-O: A Comparison Guide

from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)
tools = [search_tool, calculator_tool]

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

response = agent.run("What is the weather in Seattle?")

// Planner Agent Service (gRPC)
public class PlannerAgentService : AgentService.AgentServiceBase
{
    private readonly IChatClient _chatClient;
    private readonly AgentMcpToolsHelper _mcpToolsHelper;

    public override async Task<AgentResponse> ExecuteTask(
        AgentRequest request,
        ServerCallContext context)
    {
        // Get tools (equivalent to LangChain tools)
        var mcpTools = await _mcpToolsHelper.GetPlannerToolsAsync();

        // Create agent with BIP identity
        var agent = new ChatClientAgent(
            _chatClient,
            new ChatClientAgentOptions
            {
                Name = "Planner",
                ChatOptions = new ChatOptions
                {
                    Instructions = @"I AM the Planner.
I TRANSFER complex intent into minimal viable plans.",
                    Tools = mcpTools
                }
            });

        var thread = agent.GetNewThread();
        var response = await agent.RunAsync(
            new ChatMessage(ChatRole.User, request.Intent),
            thread);

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

from langchain.chains import LLMChain, SimpleSequentialChain

plan_chain = LLMChain(llm=llm, prompt=plan_prompt)
code_chain = LLMChain(llm=llm, prompt=code_prompt)

overall_chain = SimpleSequentialChain(
    chains=[plan_chain, code_chain],
    verbose=True
)

result = overall_chain.run("Build a REST API")

// Orchestrator coordinates PMCR-O phases
public class OrchestrationApiController : ControllerBase
{
    [HttpPost("execute")]
    public async Task<IActionResult> ExecuteAsync([FromBody] AgentRequest request)
    {
        // 1. Planner phase (equivalent to plan_chain)
        var plannerResponse = await _plannerClient.ExecuteTaskAsync(
            new AgentRequest { Intent = request.Intent });

        // 2. Maker phase (equivalent to code_chain)
        var makerResponse = await _makerClient.ExecuteTaskAsync(
            new AgentRequest { Intent = plannerResponse.Content });

        // 3. Checker phase (validation)
        var checkerResponse = await _checkerClient.ExecuteTaskAsync(
            new AgentRequest { Intent = makerResponse.Content });

        // 4. Reflector phase (self-improvement)
        var reflectorResponse = await _reflectorClient.ExecuteTaskAsync(
            new AgentRequest { Intent = checkerResponse.Content });

        return Ok(new
        {
            Plan = plannerResponse.Content,
            Artifact = makerResponse.Content,
            Validation = checkerResponse.Content,
            Reflection = reflectorResponse.Content
        });
    }
}

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
agent = initialize_agent(
    tools, llm, agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory
)

# Memory persists within conversation
response = agent.run("What did I ask about earlier?")

// Cognitive trails persist beyond sessions
public class PlannerAgentService : AgentService.AgentServiceBase
{
    private readonly KnowledgeVaultService _knowledgeVault;

    public override async Task<AgentResponse> ExecuteTask(
        AgentRequest request,
        ServerCallContext context)
    {
        // Query past cognitive trails (semantic search)
        var pastSolutions = await _knowledgeVault.SearchAsync(
            request.Intent, topK: 3);

        // Build context from past solutions
        var contextPrompt = pastSolutions.Any()
            ? $"Similar past solutions:\n{string.Join("\n", pastSolutions.Select(s => $"- {s.Content}"))}"
            : "No similar past solutions found.";

        // Generate plan with context
        var response = await GeneratePlanAsync(request.Intent, contextPrompt);

        // Store this plan as cognitive trail
        await _knowledgeVault.StoreAsync(
            response.Content,
            source: "planner",
            metadata: JsonSerializer.Serialize(new { Intent = request.Intent }));

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

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents, embeddings)

# Similarity search
docs = vectorstore.similarity_search("authentication", k=3)

// pgvector with PostgreSQL
public class KnowledgeVaultService
{
    private readonly KnowledgeDbContext _db;
    private readonly EmbeddingService _embeddingService;

    public async Task<List<KnowledgeItem>> SearchAsync(string query, int topK = 5)
    {
        // Generate embedding
        var queryEmbedding = await _embeddingService.GenerateEmbeddingAsync(query);

        // Vector similarity search (cosine similarity)
        var results = await _db.KnowledgeEntries
            .Select(k => new
            {
                Item = k,
                Similarity = EF.Functions.VectorCosineSimilarity(k.Embedding, queryEmbedding)
            })
            .Where(x => x.Similarity >= 0.7)
            .OrderByDescending(x => x.Similarity)
            .Take(topK)
            .Select(x => x.Item)
            .ToListAsync();

        return results;
    }
}