When building applications on top of Large Language Models (LLMs), you quickly realize you need more than just API calls. You need a way to chain prompts, connect to data sources, and orchestrate complex workflows. This is where AI orchestration frameworks come in.

For a long time, the dominant player has been LangChain, a powerful, Python-first library. But Microsoft has entered the scene with Semantic Kernel, a .NET-native solution designed to be lightweight, extensible, and enterprise-ready.

So, which one should a .NET developer choose?

Note: Both libraries are evolving rapidly. The code examples below reflect the state of the libraries as of late 2025. Always check the official documentation for the latest breaking changes.

Philosophy and Design

#

LangChain:

• Kitchen Sink Included: LangChain aims to be an all-encompassing framework. It has a vast number of integrations for models, vector stores, and tools right out of the box.
• Convention over Configuration: It often provides high-level, “magical” chains that perform complex tasks with minimal code. This is great for rapid prototyping.
• Python-Centric: While it has a JavaScript/TypeScript port, its primary development and community are in the Python ecosystem. The .NET port, LangChain.NET, is a community-driven effort and often lags behind the Python version in features.

Semantic Kernel:

• Minimalist Core: Semantic Kernel starts with a small, elegant core. You, the developer, plug in the components you need (e.g., a connector for OpenAI, another for ChromaDB).
• Configuration over Convention: It forces a more deliberate and structured approach. You explicitly define your plugins, memory, and connectors. This can mean more boilerplate but leads to more maintainable code.
• .NET First: It’s designed from the ground up for the .NET ecosystem, with idiomatic C# and full support from Microsoft.

Feature Comparison

#

Code Example: A Simple RAG Chain

#

Let’s see how both frameworks would implement a simple RAG (Retrieval-Augmented Generation) task: answer a question using a piece of context.

LangChain.NET Example

#

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

using LangChain.Chains.LLM;
using LangChain.Prompts;
using LangChain.Providers.OpenAI;

// Setup
var llm = new Gpt35Turbo(Environment.GetEnvironmentVariable("OPENAI_API_KEY"));
var template = "Context: {context}\n\nQuestion: {question}\n\nAnswer:";
var prompt = new PromptTemplate(template, new[] { "context", "question" });
var chain = new LlmChain(llm, prompt);

// Execution
var context = "The .NET Framework was first released in 2002.";
var question = "When was .NET released?";

var result = await chain.CallAsync(new Dictionary<string, object>
{
    { "context", context },
    { "question", question }
});

Console.WriteLine(result.Value["text"]);
// Expected Output: The .NET Framework was first released in 2002.

LangChain’s approach is direct and focuses on chaining the prompt and model together quickly.

Semantic Kernel Example (v1.0+)

#

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.OpenAI;

// Setup
var builder = Kernel.CreateBuilder();
builder.AddOpenAIChatCompletion(
    modelId: "gpt-3.5-turbo",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY"));

var kernel = builder.Build();

var prompt = @"
Context: {{$context}}

Question: {{$question}}

Answer:";

// Create the function from the prompt
var function = kernel.CreateFunctionFromPrompt(prompt);

// Execution
var context = "The .NET Framework was first released in 2002.";
var question = "When was .NET released?";

var arguments = new KernelArguments
{
    ["context"] = context,
    ["question"] = question
};

var result = await kernel.InvokeAsync(function, arguments);

Console.WriteLine(result.GetValue<string>());
// Expected Output: The .NET Framework was first released in 2002.

Semantic Kernel’s approach is more structured. Notice the use of KernelArguments and InvokeAsync, which are part of the modern v1.0 API. It revolves around the Kernel as the central orchestrator.

When to Choose Which?

#

• Choose LangChain.NET if:

  • You are rapidly prototyping and want access to a vast library of pre-built components (and are willing to accept that the .NET version may not have them all).
  • You are coming from a Python background and want a familiar experience.
  • Your project is small and less focused on long-term maintainability.

• Choose Semantic Kernel if:

  • You are building a production-ready, enterprise-grade application in .NET.
  • You value clean, testable, and maintainable code.
  • You want a framework that feels like idiomatic C# and integrates well with concepts like dependency injection.
  • You prefer a “bring your own dependencies” model over a monolithic framework.

Conclusion

#

For the majority of .NET developers, Semantic Kernel is the superior choice. It’s built for the ecosystem you already know and love. Its design philosophy, while requiring a bit more initial setup, pays dividends in the long run by promoting a more robust and maintainable architecture. LangChain is a fantastic tool for exploration and rapid development, but Semantic Kernel is the framework you’ll want to build your business on.

Further Reading

#

• Semantic Kernel Documentation - Official Microsoft documentation
• Semantic Kernel on GitHub - Source code and examples
• LangChain Documentation - Official LangChain docs (Python-focused)
• LangChain.NET on GitHub - The .NET port