File size: 6,473 Bytes
22087d0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
import asyncio
from typing import List, Optional, Dict, Any
from abc import ABC, abstractmethod
from core.utils.logger import logger
from core.utils.config import config

class EmbeddingProvider(ABC):
    @abstractmethod
    async def embed(self, texts: List[str]) -> List[List[float]]:
        pass
    
    @abstractmethod
    async def embed_single(self, text: str) -> List[float]:
        pass

class OpenAIEmbeddingProvider(EmbeddingProvider):
    def __init__(self, model: str = "text-embedding-3-small", api_key: Optional[str] = None):
        self.model = model
        self.api_key = api_key or config.OPENAI_API_KEY
        self._client = None
    
    @property
    def client(self):
        if self._client is None:
            try:
                from openai import AsyncOpenAI
                self._client = AsyncOpenAI(api_key=self.api_key)
            except ImportError:
                logger.error("OpenAI package not installed. Install with: pip install openai")
                raise
        return self._client
    
    async def embed(self, texts: List[str]) -> List[List[float]]:
        try:
            response = await self.client.embeddings.create(
                model=self.model,
                input=texts
            )
            return [embedding.embedding for embedding in response.data]
        except Exception as e:
            logger.error(f"OpenAI embedding error: {str(e)}")
            raise
    
    async def embed_single(self, text: str) -> List[float]:
        embeddings = await self.embed([text])
        return embeddings[0]

class VoyageAIEmbeddingProvider(EmbeddingProvider):
    def __init__(self, model: str = "voyage-2", api_key: Optional[str] = None):
        self.model = model
        self.api_key = api_key or config.VOYAGE_API_KEY
        self._client = None
    
    @property
    def client(self):
        if self._client is None:
            try:
                import voyageai
                self._client = voyageai.Client(api_key=self.api_key)
            except ImportError:
                logger.error("VoyageAI package not installed. Install with: pip install voyageai")
                raise
        return self._client
    
    async def embed(self, texts: List[str]) -> List[List[float]]:
        try:
            loop = asyncio.get_event_loop()
            result = await loop.run_in_executor(
                None,
                lambda: self.client.embed(texts, model=self.model)
            )
            return result.embeddings
        except Exception as e:
            logger.error(f"Voyage AI embedding error: {str(e)}")
            raise
    
    async def embed_single(self, text: str) -> List[float]:
        embeddings = await self.embed([text])
        return embeddings[0]

class LocalEmbeddingProvider(EmbeddingProvider):
    def __init__(self, model: str = "all-MiniLM-L6-v2"):
        self.model = model
        self._model_instance = None
    
    @property
    def model_instance(self):
        if self._model_instance is None:
            try:
                from sentence_transformers import SentenceTransformer
                self._model_instance = SentenceTransformer(self.model)
            except ImportError:
                logger.error("sentence-transformers not installed. Install with: pip install sentence-transformers")
                raise
        return self._model_instance
    
    async def embed(self, texts: List[str]) -> List[List[float]]:
        try:
            loop = asyncio.get_event_loop()
            embeddings = await loop.run_in_executor(
                None,
                lambda: self.model_instance.encode(texts, convert_to_numpy=True)
            )
            return embeddings.tolist()
        except Exception as e:
            logger.error(f"Local embedding error: {str(e)}")
            raise
    
    async def embed_single(self, text: str) -> List[float]:
        embeddings = await self.embed([text])
        return embeddings[0]

class EmbeddingService:
    def __init__(self, provider: Optional[str] = None, model: Optional[str] = None):
        self.provider_name = provider or config.MEMORY_EMBEDDING_PROVIDER or "openai"
        self.model = model
        self._provider = None
    
    @property
    def provider(self) -> EmbeddingProvider:
        if self._provider is None:
            self._provider = self._create_provider()
        return self._provider
    
    def _create_provider(self) -> EmbeddingProvider:
        provider_name = self.provider_name.lower()
        
        if provider_name == "openai":
            model = self.model or config.MEMORY_EMBEDDING_MODEL or "text-embedding-3-small"
            logger.info(f"Using OpenAI embedding provider with model: {model}")
            return OpenAIEmbeddingProvider(model=model)
        
        elif provider_name == "voyage" or provider_name == "voyageai":
            model = self.model or "voyage-2"
            logger.info(f"Using Voyage AI embedding provider with model: {model}")
            return VoyageAIEmbeddingProvider(model=model)
        
        elif provider_name == "local":
            model = self.model or "all-MiniLM-L6-v2"
            logger.info(f"Using local embedding provider with model: {model}")
            return LocalEmbeddingProvider(model=model)
        
        else:
            logger.warning(f"Unknown embedding provider: {provider_name}, falling back to OpenAI")
            return OpenAIEmbeddingProvider()
    
    async def embed_text(self, text: str) -> List[float]:
        if not text or not text.strip():
            raise ValueError("Text cannot be empty")
        
        return await self.provider.embed_single(text)
    
    async def embed_texts(self, texts: List[str]) -> List[List[float]]:
        if not texts:
            return []
        
        valid_texts = [t for t in texts if t and t.strip()]
        if not valid_texts:
            raise ValueError("All texts are empty")
        
        return await self.provider.embed(valid_texts)
    
    async def embed_batch(self, texts: List[str], batch_size: int = 100) -> List[List[float]]:
        if not texts:
            return []
        
        all_embeddings = []
        for i in range(0, len(texts), batch_size):
            batch = texts[i:i + batch_size]
            embeddings = await self.embed_texts(batch)
            all_embeddings.extend(embeddings)
        
        return all_embeddings

embedding_service = EmbeddingService()