Grundlegende Beispiele

Einfache Beispiele für den Einstieg in SmartRAG.

Dokument hochladen und durchsuchen

[ApiController]
[Route("api/[controller]")]
public class DocumentController : ControllerBase
{
    private readonly IDocumentService _documentService;
    private readonly ILogger<DocumentController> _logger;

    public DocumentController(IDocumentService documentService, ILogger<DocumentController> logger)
    {
        _documentService = documentService;
        _logger = logger;
    }

    [HttpPost("upload")]
    public async Task<ActionResult<Document>> UploadDocument(IFormFile file)
    {
        try
        {
            if (file == null || file.Length == 0)
                return BadRequest("Keine Datei ausgewählt");

            var document = await _documentService.UploadDocumentAsync(file);
            _logger.LogInformation("Dokument {FileName} erfolgreich hochgeladen", file.FileName);
            
            return Ok(document);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Fehler beim Hochladen des Dokuments");
            return StatusCode(500, "Interner Serverfehler");
        }
    }

    [HttpGet("search")]
    public async Task<ActionResult<IEnumerable<DocumentChunk>>> SearchDocuments(
        [FromQuery] string query, 
        [FromQuery] int maxResults = 10)
    {
        try
        {
            if (string.IsNullOrWhiteSpace(query))
                return BadRequest("Suchanfrage darf nicht leer sein");

            var results = await _documentService.SearchDocumentsAsync(query, maxResults);
            _logger.LogInformation("Suche nach '{Query}' ergab {Count} Ergebnisse", query, results.Count());
            
            return Ok(results);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Fehler bei der Dokumentsuche");
            return StatusCode(500, "Interner Serverfehler");
        }
    }
}

RAG-Antwort generieren

[HttpPost("ask")]
public async Task<ActionResult<RagResponse>> AskQuestion([FromBody] AskQuestionRequest request)
{
    try
    {
        if (string.IsNullOrWhiteSpace(request.Question))
            return BadRequest("Frage darf nicht leer sein");

        var response = await _documentService.GenerateRagAnswerAsync(request.Question, request.MaxResults ?? 5);
        _logger.LogInformation("RAG-Antwort für Frage '{Question}' generiert", request.Question);
        
        return Ok(response);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Fehler bei der RAG-Antwortgenerierung");
        return StatusCode(500, "Interner Serverfehler");
    }
}

public class AskQuestionRequest
{
    public string Question { get; set; }
    public int? MaxResults { get; set; }
}

Erweiterte Beispiele

Komplexere Anwendungsfälle und erweiterte Funktionen.

Batch-Dokumentenverarbeitung

[HttpPost("upload-batch")]
public async Task<ActionResult<BatchUploadResult>> UploadBatchDocuments(IFormFileCollection files)
{
    try
    {
        var results = new List<Document>();
        var errors = new List<string>();

        foreach (var file in files)
        {
            try
            {
                var document = await _documentService.UploadDocumentAsync(file);
                results.Add(document);
                _logger.LogInformation("Dokument {FileName} erfolgreich verarbeitet", file.FileName);
            }
            catch (Exception ex)
            {
                var error = $"Fehler bei {file.FileName}: {ex.Message}";
                errors.Add(error);
                _logger.LogWarning(ex, "Fehler beim Verarbeiten von {FileName}", file.FileName);
            }
        }

        return Ok(new BatchUploadResult
        {
            SuccessfulUploads = results,
            Errors = errors,
            TotalFiles = files.Count,
            SuccessCount = results.Count,
            ErrorCount = errors.Count
        });
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Fehler bei der Batch-Verarbeitung");
        return StatusCode(500, "Interner Serverfehler");
    }
}

public class BatchUploadResult
{
    public List<Document> SuccessfulUploads { get; set; }
    public List<string> Errors { get; set; }
    public int TotalFiles { get; set; }
    public int SuccessCount { get; set; }
    public int ErrorCount { get; set; }
}

Erweiterte Suche mit Filtern

[HttpPost("advanced-search")]
public async Task<ActionResult<AdvancedSearchResult>> AdvancedSearch([FromBody] AdvancedSearchRequest request)
{
    try
    {
        var searchResults = await _documentService.SearchDocumentsAsync(request.Query, request.MaxResults);
        
        // Zusätzliche Filter anwenden
        var filteredResults = searchResults
            .Where(r => request.MinSimilarityScore == null || r.SimilarityScore >= request.MinSimilarityScore)
            .Where(r => request.ContentTypes == null || !request.ContentTypes.Any() || 
                       request.ContentTypes.Contains(r.Document.ContentType))
            .OrderByDescending(r => r.SimilarityScore)
            .ToList();

        var result = new AdvancedSearchResult
        {
            Query = request.Query,
            Results = filteredResults,
            TotalResults = filteredResults.Count,
            SearchTime = DateTime.UtcNow,
            AppliedFilters = new
            {
                MinSimilarityScore = request.MinSimilarityScore,
                ContentTypes = request.ContentTypes
            }
        };

        _logger.LogInformation("Erweiterte Suche nach '{Query}' ergab {Count} gefilterte Ergebnisse", 
            request.Query, filteredResults.Count);
        
        return Ok(result);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Fehler bei der erweiterten Suche");
        return StatusCode(500, "Interner Serverfehler");
    }
}

public class AdvancedSearchRequest
{
    public string Query { get; set; }
    public int MaxResults { get; set; } = 10;
    public float? MinSimilarityScore { get; set; }
    public List<string> ContentTypes { get; set; }
}

public class AdvancedSearchResult
{
    public string Query { get; set; }
    public List<DocumentChunk> Results { get; set; }
    public int TotalResults { get; set; }
    public DateTime SearchTime { get; set; }
    public object AppliedFilters { get; set; }
}

Web API Beispiele

Vollständige Web API Controller mit allen SmartRAG-Funktionen.

Vollständiger Document Controller

[ApiController]
[Route("api/[controller]")]
[Produces("application/json")]
public class DocumentController : ControllerBase
{
    private readonly IDocumentService _documentService;
    private readonly ILogger<DocumentController> _logger;

    public DocumentController(IDocumentService documentService, ILogger<DocumentController> logger)
    {
        _documentService = documentService;
        _logger = logger;
    }

    /// 
    /// Lädt ein Dokument hoch
    /// 
    [HttpPost("upload")]
    [ProducesResponseType(typeof(Document), 200)]
    [ProducesResponseType(400)]
    [ProducesResponseType(500)]
    public async Task<ActionResult<Document>> UploadDocument(IFormFile file)
    {
        // Implementation siehe oben
    }

    /// 
    /// Ruft ein Dokument anhand der ID ab
    /// 
    [HttpGet("{id}")]
    [ProducesResponseType(typeof(Document), 200)]
    [ProducesResponseType(404)]
    public async Task<ActionResult<Document>> GetDocument(string id)
    {
        try
        {
            var document = await _documentService.GetDocumentByIdAsync(id);
            if (document == null)
                return NotFound($"Dokument mit ID {id} nicht gefunden");

            return Ok(document);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Fehler beim Abrufen des Dokuments {Id}", id);
            return StatusCode(500, "Interner Serverfehler");
        }
    }

    /// 
    /// Ruft alle Dokumente ab
    /// 
    [HttpGet]
    [ProducesResponseType(typeof(IEnumerable<Document>), 200)]
    public async Task<ActionResult<IEnumerable<Document>>> GetAllDocuments()
    {
        try
        {
            var documents = await _documentService.GetAllDocumentsAsync();
            return Ok(documents);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Fehler beim Abrufen aller Dokumente");
            return StatusCode(500, "Interner Serverfehler");
        }
    }

    /// 
    /// Löscht ein Dokument
    /// 
    [HttpDelete("{id}")]
    [ProducesResponseType(200)]
    [ProducesResponseType(404)]
    public async Task<ActionResult> DeleteDocument(string id)
    {
        try
        {
            var success = await _documentService.DeleteDocumentAsync(id);
            if (!success)
                return NotFound($"Dokument mit ID {id} nicht gefunden");

            _logger.LogInformation("Dokument {Id} erfolgreich gelöscht", id);
            return Ok();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Fehler beim Löschen des Dokuments {Id}", id);
            return StatusCode(500, "Interner Serverfehler");
        }
    }

    /// 
    /// Sucht in Dokumenten
    /// 
    [HttpGet("search")]
    [ProducesResponseType(typeof(IEnumerable<DocumentChunk>), 200)]
    public async Task<ActionResult<IEnumerable<DocumentChunk>>> SearchDocuments(
        [FromQuery] string query, 
        [FromQuery] int maxResults = 10)
    {
        // Implementation siehe oben
    }

    /// 
    /// Generiert eine RAG-Antwort
    /// 
    [HttpPost("ask")]
    [ProducesResponseType(typeof(RagResponse), 200)]
    public async Task<ActionResult<RagResponse>> AskQuestion([FromBody] AskQuestionRequest request)
    {
        // Implementation siehe oben
    }
}

Konsolenanwendung Beispiel

Einfache Konsolenanwendung mit SmartRAG-Integration.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using SmartRAG.Interfaces;

namespace SmartRAG.ConsoleApp
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var host = CreateHostBuilder(args).Build();
            
            using var scope = host.Services.CreateScope();
            var documentService = scope.ServiceProvider.GetRequiredService<IDocumentService>();
            var logger = scope.ServiceProvider.GetRequiredService<ILogger<Program>>();

            logger.LogInformation("SmartRAG Konsolenanwendung gestartet");

            while (true)
            {
                Console.WriteLine("\n=== SmartRAG Konsolenanwendung ===");
                Console.WriteLine("1. Dokument hochladen");
                Console.WriteLine("2. Dokumente durchsuchen");
                Console.WriteLine("3. Frage stellen");
                Console.WriteLine("4. Beenden");
                Console.Write("Wählen Sie eine Option (1-4): ");

                var choice = Console.ReadLine();

                try
                {
                    switch (choice)
                    {
                        case "1":
                            await UploadDocument(documentService, logger);
                            break;
                        case "2":
                            await SearchDocuments(documentService, logger);
                            break;
                        case "3":
                            await AskQuestion(documentService, logger);
                            break;
                        case "4":
                            logger.LogInformation("Anwendung wird beendet");
                            return;
                        default:
                            Console.WriteLine("Ungültige Option. Bitte wählen Sie 1-4.");
                            break;
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "Fehler bei der Ausführung");
                    Console.WriteLine($"Fehler: {ex.Message}");
                }
            }
        }

        static async Task UploadDocument(IDocumentService documentService, ILogger logger)
        {
            Console.Write("Geben Sie den Pfad zur Datei ein: ");
            var filePath = Console.ReadLine();

            if (!File.Exists(filePath))
            {
                Console.WriteLine("Datei nicht gefunden!");
                return;
            }

            var fileInfo = new FileInfo(filePath);
            var fileBytes = await File.ReadAllBytesAsync(filePath);
            var fileStream = new MemoryStream(fileBytes);
            var formFile = new FormFile(fileStream, 0, fileBytes.Length, "file", fileInfo.Name);

            var document = await documentService.UploadDocumentAsync(formFile);
            Console.WriteLine($"Dokument erfolgreich hochgeladen: {document.Id}");
        }

        static async Task SearchDocuments(IDocumentService documentService, ILogger logger)
        {
            Console.Write("Geben Sie Ihre Suchanfrage ein: ");
            var query = Console.ReadLine();

            var results = await documentService.SearchDocumentsAsync(query, 5);
            
            Console.WriteLine($"\nGefundene Ergebnisse ({results.Count()}):");
            foreach (var result in results)
            {
                Console.WriteLine($"- {result.Document.FileName} (Ähnlichkeit: {result.SimilarityScore:P2})");
                Console.WriteLine($"  {result.Content.Substring(0, Math.Min(100, result.Content.Length))}...");
            }
        }

        static async Task AskQuestion(IDocumentService documentService, ILogger logger)
        {
            Console.Write("Stellen Sie Ihre Frage: ");
            var question = Console.ReadLine();

            var response = await documentService.GenerateRagAnswerAsync(question, 5);
            
            Console.WriteLine($"\nAntwort: {response.Answer}");
            Console.WriteLine($"\nQuellen ({response.Sources.Count}):");
            foreach (var source in response.Sources)
            {
                Console.WriteLine($"- {source.DocumentName} (Ähnlichkeit: {source.SimilarityScore:P2})");
            }
        }

        static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((context, services) =>
                {
                    services.AddSmartRAG(context.Configuration, options =>
                    {
                        options.AIProvider = AIProvider.Anthropic;
                        options.StorageProvider = StorageProvider.Qdrant;
                    });
                });
    }
}

Benötigen Sie Hilfe?

Für weitere Beispiele und Unterstützung: