Changes

2026-05-14 14:12:29 +03:00
parent 92278ae375
commit 75bc9509c5
137 changed files with 0 additions and 371 deletions
@@ -0,0 +1,79 @@
+using Microsoft.AspNetCore.Mvc;
+using Swashbuckle.AspNetCore.Annotations;
+
+namespace Api.Controllers
+{
+    /// <summary>
+    /// Controller that exposes simple health and readiness endpoints for the API.
+    /// Routes are prefixed with "api/health".
+    /// </summary>
+    [ApiController]
+    [Route("api/[controller]")]
+    public sealed class HealthController : ControllerBase
+    {
+        /// <summary>
+        /// Liveness probe.
+        /// Indicates whether the process is running. Used by orchestration systems to confirm the process is alive.
+        /// </summary>
+        /// <returns>
+        /// 200 OK with JSON payload: { "status": "alive" } when the process is running.
+        /// </returns>
+        // GET api/health/live
+        [HttpGet("live")]
+        [SwaggerOperation(Summary = "Liveness probe", Description = "Returns whether the API process is alive.")]
+        [SwaggerResponse(StatusCodes.Status200OK, "Service is alive")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public IActionResult Live() => Ok(new { status = "alive" });
+
+        /// <summary>
+        /// Basic health check endpoint.
+        /// Returns overall status and the current server time in UTC.
+        /// </summary>
+        /// <returns>
+        /// 200 OK with JSON payload: { "status": "ok", "time": &lt;UTC time&gt; }.
+        /// </returns>
+        // GET api/health
+        [HttpGet]
+        [SwaggerOperation(Summary = "Health check", Description = "Returns overall health status and current UTC time.")]
+        [SwaggerResponse(StatusCodes.Status200OK, "Health check succeeded")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public IActionResult Health() => Ok(new { status = "ok", time = DateTimeOffset.UtcNow });
+
+        /// <summary>
+        /// Echo endpoint.
+        /// Returns the received JSON payload unchanged. Useful for testing request/response plumbing.
+        /// </summary>
+        /// <param name="payload">Arbitrary JSON from the request body. The endpoint returns the same object.</param>
+        /// <returns>200 OK with the same JSON payload provided in the request body.</returns>
+        // POST api/health/echo
+        [HttpPost("echo")]
+        [SwaggerOperation(Summary = "Echo payload", Description = "Returns the same JSON payload received in the request body.")]
+        [SwaggerResponse(StatusCodes.Status200OK, "Payload echoed successfully")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public IActionResult Echo(object payload) => Ok(payload);
+
+        /// <summary>
+        /// Readiness probe.
+        /// Indicates whether the service is ready to accept traffic. Typically checks downstream dependencies.
+        /// </summary>
+        /// <returns>
+        /// 200 OK with JSON { "status": "ready" } when ready;
+        /// 503 Service Unavailable with JSON { "status": "not_ready" } when not ready.
+        /// </returns>
+        // GET api/health/ready
+        [HttpGet("ready")]
+        [SwaggerOperation(Summary = "Readiness probe", Description = "Returns whether the service is ready to accept traffic.")]
+        [SwaggerResponse(StatusCodes.Status200OK, "Service is ready")]
+        [SwaggerResponse(StatusCodes.Status503ServiceUnavailable, "Service is not ready")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status503ServiceUnavailable)]
+        public IActionResult Ready()
+        {
+            var ready = true;
+
+            return ready
+                ? Ok(new { status = "ready" })
+                : StatusCode(503, new { status = "not_ready" });
+        }
+    }
+}
@@ -0,0 +1,129 @@
+using Microsoft.AspNetCore.Mvc;
+using Api.Services.Contracts;
+using Rag.Models.Requests;
+using Rag.Models.Responses;
+using Swashbuckle.AspNetCore.Annotations;
+using Shared.Models.Responses;
+
+namespace Api.Controllers;
+
+[ApiController]
+[Route("api/rag")]
+public sealed class RagController : ControllerBase
+{
+    private readonly IRagService _ragService;
+    private readonly ILogger<RagController> _logger;
+
+    public RagController(IRagService ragService, ILogger<RagController> logger)
+    {
+        _ragService = ragService;
+        _logger = logger;
+    }
+
+    [HttpPost("documents")]
+    [RequestSizeLimit(10 * 1024 * 1024)]
+    [SwaggerOperation(Summary = "Index document (multipart)", Description = "Indexes a PDF file or raw text document using multipart/form-data payload.")]
+    [SwaggerResponse(StatusCodes.Status200OK, "Document indexed successfully")]
+    [SwaggerResponse(StatusCodes.Status400BadRequest, "Invalid indexing request")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<IndexDocumentResponse>> IndexDocument(
+        [FromForm] IndexDocumentUploadRequest request,
+        CancellationToken ct)
+    {
+        try
+        {
+            _logger.LogInformation("Index document request received. HasFile={HasFile}, DocumentType={DocumentType}, Title={Title}, SourceUrl={SourceUrl}",
+                request.File is not null, request.DocumentType, request.Title, request.SourceUrl);
+
+            if (request.File is not null)
+            {
+                var result = await _ragService.IndexPdfAsync(request.File, request.DocumentType, request.Title, request.SourceUrl, ct);
+                _logger.LogInformation("Indexed PDF document. DocumentId={DocumentId}, DocumentType={DocumentType}, Chunks={Chunks}, Cached={Cached}",
+                    result.DocumentId, result.DocumentType, result.Chunks, result.Cached);
+                return Ok(result);
+            }
+
+            var textResult = await _ragService.IndexTextAsync(new IndexDocumentRequest
+            {
+                Text = request.Text,
+                DocumentType = request.DocumentType,
+                Title = request.Title,
+                SourceUrl = request.SourceUrl
+            }, ct);
+            _logger.LogInformation("Indexed text document. DocumentId={DocumentId}, DocumentType={DocumentType}, Chunks={Chunks}, Cached={Cached}",
+                textResult.DocumentId, textResult.DocumentType, textResult.Chunks, textResult.Cached);
+            return Ok(textResult);
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning(ex, "Invalid document indexing request.");
+            return BadRequest(new ErrorResponse { Error = ex.Message, Code = "invalid_request" });
+        }
+    }
+
+    [HttpPost("documents/json")]
+    [SwaggerOperation(Summary = "Index document (JSON)", Description = "Indexes a text document sent as JSON.")]
+    [SwaggerResponse(StatusCodes.Status200OK, "JSON document indexed successfully")]
+    [SwaggerResponse(StatusCodes.Status400BadRequest, "Invalid JSON indexing request")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<IndexDocumentResponse>> IndexJsonDocument([FromBody] IndexDocumentRequest request, CancellationToken ct)
+    {
+        try
+        {
+            _logger.LogInformation("JSON document indexing request received. DocumentType={DocumentType}, Title={Title}, SourceUrl={SourceUrl}",
+                request.DocumentType, request.Title, request.SourceUrl);
+            var result = await _ragService.IndexTextAsync(request, ct);
+            _logger.LogInformation("Indexed JSON document. DocumentId={DocumentId}, DocumentType={DocumentType}, Chunks={Chunks}, Cached={Cached}",
+                result.DocumentId, result.DocumentType, result.Chunks, result.Cached);
+            return Ok(result);
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning(ex, "Invalid JSON document indexing request.");
+            return BadRequest(new ErrorResponse { Error = ex.Message, Code = "invalid_request" });
+        }
+    }
+
+    [HttpPost("search")]
+    [SwaggerOperation(Summary = "Semantic search", Description = "Performs semantic retrieval over indexed documents.")]
+    [SwaggerResponse(StatusCodes.Status200OK, "Search results returned")]
+    [SwaggerResponse(StatusCodes.Status400BadRequest, "Invalid search request")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<SearchResponse>> Search([FromBody] SearchRequest request, CancellationToken ct)
+    {
+        try
+        {
+            _logger.LogInformation("Semantic search request received. TargetTypes={TargetTypes}, TopK={TopK}",
+                string.Join(',', request.TargetDocumentTypes ?? System.Array.Empty<string>()), request.TopK);
+            var result = await _ragService.SearchAsync(request, ct);
+            _logger.LogInformation("Semantic search completed. ResultCount={ResultCount}", result.Results.Count);
+            return Ok(result);
+        }
+        catch (InvalidOperationException ex)
+        {
+            _logger.LogWarning(ex, "Invalid semantic search request.");
+            return BadRequest(new ErrorResponse { Error = ex.Message, Code = "invalid_request" });
+        }
+    }
+
+    [HttpGet("documents/{id}")]
+    [SwaggerOperation(Summary = "Get document details", Description = "Returns indexed document details for the provided document id.")]
+    [SwaggerResponse(StatusCodes.Status200OK, "Document details returned")]
+    [SwaggerResponse(StatusCodes.Status404NotFound, "Document was not found")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ErrorResponse), StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<RagDocumentDetailsResponse>> GetDocument(string id, CancellationToken ct)
+    {
+        _logger.LogInformation("Get document request received. DocumentId={DocumentId}", id);
+        var document = await _ragService.GetDocumentAsync(id, ct);
+        if (document is null)
+        {
+            _logger.LogWarning("Document not found. DocumentId={DocumentId}", id);
+            return NotFound(new ErrorResponse { Error = "Document not found.", Code = "document_not_found" });
+        }
+        return Ok(document);
+    }
+}