WeaveLLM.Core 0.1.0-alpha

WeaveLLM 🧵

The AI orchestration framework built for .NET — strongly typed, production-ready, and genuinely extensible.

Strongly typed LangChain alternative for .NET — chains, agents, RAG, and multi-agent graphs built for production.

Why WeaveLLM?

Python's AI tooling is powerful but chaotic. LangChain suffers from abstraction leakage, opaque errors, and duck-typing that explodes at runtime. .NET developers deserve better.

Quick Start

dotnet add package WeaveLLM.Core
dotnet add package WeaveLLM.Providers
dotnet add package WeaveLLM.Extensions.DependencyInjection

// Program.cs
builder.Services
    .AddWeaveLLM()
    .AddOpenAI(apiKey: "sk-...")
    .AddInMemoryMemory()
    .AddToolRegistry(r => r.RegisterFromObject(new WebSearchTool()))
    .AddReActAgent();

// In your controller / minimal API:
var result = await agent.RunAsync("What is the weather in Sheffield today?");
Console.WriteLine(result.FinalAnswer);

Core Concepts

Chains — the atomic unit

// Every chain is IChain<TInput, TOutput> — no surprises at runtime.
var result = await model.ChatAsync(
    messages: [Message.User("Explain transformers in one paragraph")],
    options: LLMOptions.Balanced()
);

if (result.IsSuccess)
    Console.WriteLine(result.Value.Content);
else
    Console.WriteLine($"Failed: {result.Error.Code} — {result.Error.Message}");

Streaming — native IAsyncEnumerable

await foreach (var chunk in model.StreamChatAsync([Message.User("Write a poem")]))
{
    Console.Write(chunk); // tokens arrive as they're generated
}

Tool use — zero boilerplate

public sealed class MyTools
{
    [LLMTool("search_web", "Search the internet for current information")]
    public async Task<string> SearchAsync(
        [Description("The search query")] string query,
        [Description("Max results to return")] int maxResults = 5)
    {
        // your implementation
        return searchResults;
    }
}

// Register — that's it. WeaveLLM generates the JSON schema automatically.
registry.RegisterFromObject(new MyTools());

RAG Pipeline

// Index documents
var indexResult = await rag.IndexAsync([
    new Document { Content = File.ReadAllText("docs.txt"), Source = "docs.txt" }
]);

// Query with hybrid search
var answer = await rag.QueryAsync("How do I configure authentication?");
Console.WriteLine(answer.Value);

Multi-Agent Graphs — the LangGraph equivalent

var graph = AgentGraph<ResearchState>.Create()
    .AddNode("researcher", async (state, ctx, ct) => {
        state.Notes = await ResearchTopic(state.Question);
        return state;
    })
    .AddNode("writer", async (state, ctx, ct) => {
        state.Draft = await WriteDraft(state.Notes);
        return state;
    })
    .AddNode("critic", async (state, ctx, ct) => {
        state.NeedsRevision = await Critique(state.Draft);
        return state;
    })
    .SetEntryPoint("researcher")
    .AddEdge("researcher", "writer")
    .AddEdge("writer", "critic")
    .AddConditionalEdge("critic",
        state => state.NeedsRevision ? "revise" : "finalize",
        new() { ["revise"] = "writer", ["finalize"] = "done" })
    .SetEndPoint("done");

var result = await graph.RunAsync(new ResearchState { Question = "Explain quantum computing" });

Middleware — cross-cutting concerns

// Apply retry + caching to any chain
var chain = myChain
    .WithMiddleware(new RetryMiddleware<Input, Output>(maxRetries: 3))
    .WithMiddleware(new CacheMiddleware<Input, Output>(ttl: TimeSpan.FromMinutes(10)));

Supported Providers

Package Structure

WeaveLLM.Core                          — Interfaces, models, base abstractions
WeaveLLM.Providers                     — OpenAI, Anthropic, Azure, Ollama providers
WeaveLLM.Memory                        — Redis, Postgres, CosmosDB memory stores
WeaveLLM.Observability                 — OpenTelemetry, metrics, LLM evaluators
WeaveLLM.Extensions.DependencyInjection — IServiceCollection fluent builder

Roadmap

• Core chain abstractions + middleware pipeline
• OpenAI + Anthropic providers
• In-memory store + RAG pipeline
• ReAct agent + AgentGraph
• OpenTelemetry integration
• Redis + pgvector memory backends
• Ollama local model support
• Blazor visual chain builder (ChainForge)
• Prompt versioning + A/B testing server (PromptVault)
• RAGAS-equivalent evaluation suite (EvalKit.NET)
• Azure Aspire integration dashboard

Contributing

Contributions welcome. Please read CONTRIBUTING.md first.

License

MIT — free for personal and commercial use. See LICENSE.

Built with ❤️ for the .NET community. If this project helps you, please ⭐ the repo.