embedcache 0.1.1

High-performance text embedding service with caching capabilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

# Architecture

This section describes the architecture and design of EmbedCache.

## Overview

EmbedCache is designed with modularity and extensibility in mind. It can be used as:

1. **Standalone REST API Service** - HTTP endpoints for embedding generation
2. **Rust Library** - Direct integration into Rust applications

## High-Level Architecture

```
┌─────────────────────────────────────────────────────────────┐
│                        Clients                               │
│              (HTTP Requests / Library Calls)                 │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                      HTTP Layer                              │
│                    (Actix-web Server)                        │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │ /v1/embed   │  │ /v1/process │  │ /v1/params  │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                     Core Processing                          │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                    Handlers                          │    │
│  │  ┌─────────┐  ┌─────────────┐  ┌───────────────┐   │    │
│  │  │ Embed   │  │   Process   │  │   Features    │   │    │
│  │  └─────────┘  └─────────────┘  └───────────────┘   │    │
│  └─────────────────────────────────────────────────────┘    │
│                              │                               │
│  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐   │
│  │   Chunking    │  │   Embedding   │  │    Cache      │   │
│  │  ┌─────────┐  │  │  ┌─────────┐  │  │  ┌─────────┐  │   │
│  │  │  Word   │  │  │  │FastEmbed│  │  │  │ SQLite  │  │   │
│  │  │LLM Conc.│  │  │  └─────────┘  │  │  └─────────┘  │   │
│  │  │LLM Intro│  │  │               │  │               │   │
│  │  └─────────┘  │  └───────────────┘  └───────────────┘   │
│  └───────────────┘                                          │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    External Services                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │   Ollama    │  │   OpenAI    │  │  Anthropic  │         │
│  │  (LLM API)  │  │  (LLM API)  │  │  (LLM API)  │         │
│  └─────────────┘  └─────────────┘  └─────────────┘         │
└─────────────────────────────────────────────────────────────┘
```

## Request Flow

### /v1/embed (Text Embedding)

```
1. Receive JSON request with text list
2. Parse configuration (or use defaults)
3. Load appropriate embedding model
4. Generate embeddings via FastEmbed
5. Return embedding vectors
```

### /v1/process (URL Processing)

```
1. Receive JSON request with URL
2. Generate cache key from URL + config
3. Check cache for existing result
4. If cached: return immediately
5. If not cached:
   a. Fetch URL content (readability)
   b. Chunk content (word/LLM chunker)
   c. Generate embeddings
   d. Store in cache
   e. Return result
```

## Topics

- [Design Decisions](design.md) - Why things are built this way
- [Module Structure](modules.md) - Source code organization