AgenticRAG.NET 1.0.0

AgenticRAG.NET

AgenticRAG.NET is a cutting-edge .NET framework that brings state-of-the-art Agentic Retrieval-Augmented Generation (RAG) capabilities to the .NET ecosystem. Unlike traditional RAG systems, AgenticRAG.NET enables intelligent agents that can plan, reason, reflect, and dynamically adapt their retrieval and response strategies.

Created by AgiCodes - Sajjad | 📧 asajjad308@gmail.com | ☕ Buy Me a Coffee

🧠 What is Agentic RAG?

Agentic RAG represents the next evolution of retrieval-augmented systems, combining:

• Dynamic Retrieval: Agents decide what to retrieve, when to stop, and how to refine their search
• Multi-step Reasoning: Complex queries are broken down into logical steps
• Tool Integration: Seamless use of external tools (calculators, web search, APIs)
• Self-Reflection: Agents evaluate and improve their own responses
• Memory & Context: Persistent memory across conversations and sessions

🚀 Key Features

Core Capabilities

• Intelligent Planning: Agents create and execute multi-step plans for complex queries
• Dynamic Retrieval: Multiple retriever types (vector, keyword, API) with context-aware selection
• Tool Ecosystem: Pluggable tool system with built-in utilities and easy extensibility
• Reflection Engine: Self-evaluation and response improvement capabilities
• Memory Management: Multiple storage backends (in-memory, Redis, SQLite)
• Explainable AI: Complete reasoning traces for transparency and debugging

Built-in Components

• Retrievers: Vector similarity, keyword search, API-based retrieval
• Tools: Web search, calculator, summarizer, and more
• Memory Stores: In-memory, Redis, and SQLite implementations
• LLM Adapters: Support for OpenAI, Azure OpenAI, Ollama, and local models

📦 Package Structure

🏁 Quick Start

Installation

dotnet add package AgenticRAG.Core
dotnet add package AgenticRAG.Retrievers
dotnet add package AgenticRAG.Tools
dotnet add package AgenticRAG.Memory

Basic Usage

using AgenticRAG.Core.Builders;
using AgenticRAG.Core.Interfaces;
using AgenticRAG.Memory;
using AgenticRAG.Retrievers;
using AgenticRAG.Tools;

// Create a RAG agent
var agent = new RagAgentBuilder()
    .UseModel(new OpenAIChatModel("gpt-4o", apiKey))
    .UseRetriever("VectorRetriever", new QdrantRetriever(apiKey))
    .UseTool(new WebSearchTool(httpClient, options))
    .UseTool(new CalculatorTool())
    .UseMemoryStore(new RedisMemoryStore(database))
    .UseReflectionEngine()
    .Build();

// Ask a question
var response = await agent.AskAsync("What are the latest developments in quantum computing?");

Console.WriteLine($"Answer: {response.Content}");
Console.WriteLine($"Confidence: {response.ConfidenceScore:F2}");
Console.WriteLine($"Retrieved Documents: {response.RetrievedDocuments.Count}");

Advanced Configuration

var agent = new RagAgentBuilder()
    .UseModel(chatModel)
    .UseRetriever("VectorRetriever", vectorRetriever)
    .UseRetriever("KeywordRetriever", keywordRetriever)
    .UseRetriever("ApiRetriever", apiRetriever)
    .UseTool(webSearchTool)
    .UseTool(calculatorTool)
    .UseTool(customTool)
    .UseMemoryStore(memoryStore)
    .UseReflectionEngine()
    .WithOptions(new RagAgentOptions(
        EnableReflection: true,
        MaxRetrievalSteps: 5,
        MaxToolExecutions: 3,
        ResponseTemperature: 0.7,
        MaxResponseTokens: 2000,
        MinConfidenceThreshold: 0.6))
    .Build();

🧩 Architecture

User Query
    ↓
[Agent Controller]
    ↓ (plans approach)
[Tool Manager] ←→ [Retriever Manager]
    ↓ (retrieves context)
[Reflection Engine] ←→ [LLM/Completion Model]
    ↓
Final Answer + Reasoning Trace

Core Components

1. AgentController: Orchestrates the reasoning loop (Plan → Retrieve → Generate → Reflect → Act)
2. RetrieverManager: Manages multiple retrievers and selects appropriate ones
3. ToolManager: Handles tool registration and execution
4. ReflectionEngine: Evaluates response quality and suggests improvements
5. MemoryStore: Persists conversations, queries, and retrieved documents

🔧 Customization

Creating Custom Retrievers

public class CustomRetriever : IRetriever
{
    public string Name => "CustomRetriever";

    public async Task<IReadOnlyList<RetrievedDocument>> RetrieveAsync(
        string query, 
        RetrievalOptions? options = null, 
        CancellationToken cancellationToken = default)
    {
        // Your custom retrieval logic
        return retrievedDocuments;
    }
}

Creating Custom Tools

public class CustomTool : IAgentTool
{
    public string Name => "CustomTool";
    public string Description => "Description of what this tool does";

    public JsonElement InputSchema => JsonSerializer.SerializeToElement(new
    {
        type = "object",
        properties = new
        {
            input = new { type = "string", description = "Input parameter" }
        },
        required = new[] { "input" }
    });

    public async Task<ToolResult> ExecuteAsync(
        JsonElement input, 
        CancellationToken cancellationToken = default)
    {
        // Your custom tool logic
        return new ToolResult(true, result);
    }
}

Custom Memory Stores

public class CustomMemoryStore : IMemoryStore
{
    // Implement IMemoryStore interface
    // with your custom storage backend
}

📊 Example Scenarios

1. Research and Analysis

var response = await agent.AskAsync(
    "Research the current state of renewable energy and calculate the potential cost savings for a household");

2. Mathematical Problem Solving

var response = await agent.AskAsync(
    "Calculate the compound interest for $10,000 invested at 5% for 10 years, then summarize the key financial concepts");

3. Multi-step Information Gathering

var response = await agent.AskAsync(
    "Find the latest AI safety research papers, summarize the key findings, and identify the most important recommendations");

🔍 Reasoning and Transparency

AgenticRAG.NET provides complete transparency into the agent's reasoning process:

var response = await agent.AskAsync("Your question here");

// Access the complete reasoning trace
foreach (var step in response.ReasoningTrace)
{
    Console.WriteLine($"{step.StepType}: {step.Description}");
    Console.WriteLine($"Input: {step.Input}");
    Console.WriteLine($"Output: {step.Output}");
    Console.WriteLine($"Timestamp: {step.Timestamp}");
}

🚀 Performance and Scalability

• Async/Await: Full async support for high-performance scenarios
• Caching: Built-in caching for retrieved documents and responses
• Memory Management: Efficient memory usage with configurable retention policies
• Concurrent Processing: Support for concurrent agent operations
• Resource Pooling: Connection pooling for external services

🔒 Security and Privacy

• Input Sanitization: Automatic sanitization of user inputs
• Tool Security: Safe execution environment for custom tools
• Data Encryption: Support for encrypted storage backends
• Access Control: Configurable access controls for different components

🧪 Testing

[Test]
public async Task Agent_Should_Handle_Complex_Query()
{
    // Arrange
    var agent = CreateTestAgent();
    
    // Act
    var response = await agent.AskAsync("Complex query here");
    
    // Assert
    Assert.That(response.ConfidenceScore, Is.GreaterThan(0.7));
    Assert.That(response.RetrievedDocuments, Is.Not.Empty);
    Assert.That(response.ReasoningTrace, Is.Not.Empty);
}

🤝 Contributing

We welcome contributions! Please see our Contributing Guidelines for details.

Development Setup

1. Clone the repository
2. Install .NET 9.0 SDK
3. Run dotnet restore
4. Run dotnet build
5. Run dotnet test

📈 Roadmap

• v1.1: Blazor UI Dashboard
• v1.2: Advanced Vector Stores (Pinecone, Weaviate)
• v1.3: Multi-Agent Collaboration
• v1.4: Knowledge Graph Integration
• v1.5: Advanced Reflection Strategies
• v2.0: Production-Ready Enterprise Features

📚 Documentation

• API Reference
• Architecture Guide
• Best Practices
• Troubleshooting

🆘 Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Documentation: Wiki

💝 Support the Project

Created by AgiCodes - Sajjad

If you find AgenticRAG.NET useful, please consider supporting the project:

• ☕ Buy Me a Coffee - Support ongoing development
• 📧 Email: asajjad308@gmail.com - Direct contact for questions
• ⭐ Star the Repository - Help others discover the project
• 🐛 Report Issues - Help improve the framework
• 💡 Suggest Features - Contribute to the roadmap

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Inspired by research in Agentic RAG and multi-agent systems
• Built on top of the .NET ecosystem and Microsoft's Semantic Kernel
• Community feedback and contributions

AgenticRAG.NET - Bringing the future of intelligent retrieval to .NET developers. 🚀