Download core/memory/embedding_service.py from Kyrlos11/nniback: direct link, hf CLI and curl.
- Browser
- Download file 6.47 kB
-
https://huggingface.co/spaces/Kyrlos11/nniback/resolve/main/core/memory/embedding_service.py
- Command line
-
hf download hf://spaces/Kyrlos11/nniback/core/memory/embedding_service.py
-
curl -L -o embedding_service.py https://huggingface.co/spaces/Kyrlos11/nniback/resolve/main/core/memory/embedding_service.py
6.47 kB
| 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): | |
| async def embed(self, texts: List[str]) -> List[List[float]]: | |
| pass | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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() | |