feat: allow to fetch entry from collection

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

Author: mudler

pkg/client/client.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"mime/multipart"
 	"net/http"
+	"net/url"
 	"os"
 
 	"github.com/mudler/localrecall/rag/types"
@@ -74,7 +75,7 @@ func (c *Client) ListCollections() ([]string, error) {
 	return collections, nil
 }
 
-// ListCollections lists all collections
+// ListEntries lists all entries in a collection
 func (c *Client) ListEntries(collection string) ([]string, error) {
 	url := fmt.Sprintf("%s/api/collections/%s/entries", c.BaseURL, collection)
 
@@ -85,16 +86,61 @@ func (c *Client) ListEntries(collection string) ([]string, error) {
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		return nil, errors.New("failed to list collections")
+		return nil, errors.New("failed to list entries")
+	}
+
+	var result struct {
+		Data struct {
+			Entries []string `json:"entries"`
+		} `json:"data"`
+	}
+	err = json.NewDecoder(resp.Body).Decode(&result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result.Data.Entries, nil
+}
+
+// EntryChunk is a single chunk of an entry's content (id, content, metadata only).
+type EntryChunk struct {
+	ID       string            `json:"id"`
+	Content  string            `json:"content"`
+	Metadata map[string]string `json:"metadata"`
+}
+
+// GetEntryContent returns the chunks (id, content, metadata) for a specific entry in a collection.
+func (c *Client) GetEntryContent(collection, entry string) ([]EntryChunk, error) {
+	apiURL := fmt.Sprintf("%s/api/collections/%s/entries/%s", c.BaseURL, collection, url.PathEscape(entry))
+
+	resp, err := http.Get(apiURL)
+	if err != nil {
+		return nil, err
 	}
+	defer resp.Body.Close()
 
-	var entries []string
-	err = json.NewDecoder(resp.Body).Decode(&entries)
+	switch resp.StatusCode {
+	case http.StatusOK:
+		break
+	case http.StatusNotFound:
+		return nil, errors.New("collection or entry not found")
+	case http.StatusNotImplemented:
+		return nil, errors.New("this collection backend does not support listing entry content")
+	default:
+		return nil, fmt.Errorf("failed to get entry content: status %d", resp.StatusCode)
+	}
+
+	var result struct {
+		Data struct {
+			Chunks []EntryChunk `json:"chunks"`
+		} `json:"data"`
+	}
+	err = json.NewDecoder(resp.Body).Decode(&result)
 	if err != nil {
 		return nil, err
 	}
 
-	return entries, nil
+	return result.Data.Chunks, nil
 }
 
 // DeleteEntry deletes an Entry in a collection and return the entries left

rag/persistency.go

@@ -208,6 +208,29 @@ func (db *PersistentKB) EntryExists(entry string) bool {
 	return false
 }
 
+// GetEntryContent returns all chunks (content, id, metadata) for the given entry.
+// It uses the in-memory index and Engine.GetByID to resolve full chunk data.
+func (db *PersistentKB) GetEntryContent(entry string) ([]types.Result, error) {
+	db.Lock()
+	defer db.Unlock()
+
+	entry = filepath.Base(entry)
+	chunkResults, ok := db.index[entry]
+	if !ok {
+		return nil, fmt.Errorf("entry not found: %s", entry)
+	}
+
+	results := make([]types.Result, 0, len(chunkResults))
+	for _, r := range chunkResults {
+		full, err := db.Engine.GetByID(r.ID)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get chunk %s: %w", r.ID, err)
+		}
+		results = append(results, full)
+	}
+	return results, nil
+}
+
 // Store stores an entry in the persistent knowledge base.
 func (db *PersistentKB) Store(entry string, metadata map[string]string) error {
 	db.Lock()

routes.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
@@ -125,6 +126,7 @@ func registerAPIRoutes(e *echo.Echo, openAIClient *openai.Client, maxChunkingSiz
 	e.POST("/api/collections/:name/upload", uploadFile(collections, fileAssets))
 	e.GET("/api/collections", listCollections)
 	e.GET("/api/collections/:name/entries", listFiles(collections))
+	e.GET("/api/collections/:name/entries/:entry", getEntryContent(collections))
 	e.POST("/api/collections/:name/search", search(collections))
 	e.POST("/api/collections/:name/reset", reset(collections))
 	e.DELETE("/api/collections/:name/entry/delete", deleteEntryFromCollection(collections))
@@ -271,6 +273,51 @@ func listFiles(collections collectionList) func(c echo.Context) error {
 	}
 }
 
+// getEntryContent returns the chunks (id, content, metadata) for a specific entry in a collection.
+func getEntryContent(collections collectionList) func(c echo.Context) error {
+	return func(c echo.Context) error {
+		name := c.Param("name")
+		collection, exists := collections[name]
+		if !exists {
+			return c.JSON(http.StatusNotFound, errorResponse(ErrCodeNotFound, "Collection not found", fmt.Sprintf("Collection '%s' does not exist", name)))
+		}
+
+		entryParam := c.Param("entry")
+		entry, err := url.PathUnescape(entryParam)
+		if err != nil {
+			entry = entryParam
+		}
+
+		results, err := collection.GetEntryContent(entry)
+		if err != nil {
+			if strings.Contains(err.Error(), "entry not found") {
+				return c.JSON(http.StatusNotFound, errorResponse(ErrCodeNotFound, "Entry not found", fmt.Sprintf("Entry '%s' does not exist in collection '%s'", entry, name)))
+			}
+			if strings.Contains(err.Error(), "not implemented") {
+				return c.JSON(http.StatusNotImplemented, errorResponse(ErrCodeInternalError, "Not supported", "This collection backend does not support listing entry content"))
+			}
+			return c.JSON(http.StatusInternalServerError, errorResponse(ErrCodeInternalError, "Failed to get entry content", err.Error()))
+		}
+
+		chunks := make([]map[string]interface{}, 0, len(results))
+		for _, r := range results {
+			chunks = append(chunks, map[string]interface{}{
+				"id":       r.ID,
+				"content":  r.Content,
+				"metadata": r.Metadata,
+			})
+		}
+
+		response := successResponse("Entry content retrieved successfully", map[string]interface{}{
+			"collection": name,
+			"entry":      entry,
+			"chunks":     chunks,
+			"count":      len(chunks),
+		})
+		return c.JSON(http.StatusOK, response)
+	}
+}
+
 // uploadFile handles uploading files to a collection
 func uploadFile(collections collectionList, fileAssets string) func(c echo.Context) error {
 	return func(c echo.Context) error {