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()
|