Isaac Quarenta
fix: OpenRouter Nemotron embeddings correct model ID + timezone UTC+1 + web search improvements
f957231 Download modules/cloudflare_embeddings.py from akra35567/Akiragpu: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/spaces/akra35567/Akiragpu/resolve/main/modules/cloudflare_embeddings.py
- Command line
-
hf download hf://spaces/akra35567/Akiragpu/modules/cloudflare_embeddings.py
-
curl -L -o cloudflare_embeddings.py https://huggingface.co/spaces/akra35567/Akiragpu/resolve/main/modules/cloudflare_embeddings.py
10.7 kB
| """ | |
| Remote Embeddings Module β Multi-Provider with Fallback Chain | |
| TIER 1: OpenRouter Nemotron 3 Embed 1B (free, no limit, 1024d) | |
| TIER 2: Cloudflare Workers AI bge-m3 (free 10k/day, 1024d) | |
| TIER 3: SentenceTransformer local (offline fallback) | |
| All providers produce 1024-dimensional embeddings for compatibility. | |
| """ | |
| import os | |
| import time | |
| from typing import List, Optional | |
| import numpy as np | |
| import requests | |
| from loguru import logger | |
| # ============================================================ | |
| # TIER 1: OpenRouter Nemotron 3 Embed 1B (free, no limit) | |
| # ============================================================ | |
| class OpenRouterEmbeddings: | |
| """ | |
| OpenRouter Nemotron 3 Embed 1B β free text embedding model. | |
| 1024 dimensions, high quality for RAG/retrieval tasks. | |
| API: OpenAI-compatible /v1/embeddings endpoint. | |
| """ | |
| EMBEDDING_DIM = 1024 | |
| MODEL = "nvidia/nemotron-3-embed-1b:free" | |
| API_URL = "https://openrouter.ai/api/v1/embeddings" | |
| MIN_REQUEST_INTERVAL = 0.1 | |
| def __init__(self, api_key: Optional[str] = None): | |
| self._api_key = api_key or os.getenv("OPENROUTER_API_KEY") | |
| self._last_request_time = 0.0 | |
| def is_available(self) -> bool: | |
| return bool(self._api_key) | |
| def _embed_via_openai(self, input_data, api_key: str) -> Optional[dict]: | |
| """Call OpenRouter embeddings endpoint (OpenAI-compatible).""" | |
| headers = { | |
| "Authorization": f"Bearer {api_key}", | |
| "Content-Type": "application/json", | |
| } | |
| payload = { | |
| "model": self.MODEL, | |
| "input": input_data, | |
| } | |
| elapsed = time.time() - self._last_request_time | |
| if elapsed < self.MIN_REQUEST_INTERVAL: | |
| time.sleep(self.MIN_REQUEST_INTERVAL - elapsed) | |
| self._last_request_time = time.time() | |
| try: | |
| resp = requests.post(self.API_URL, headers=headers, json=payload, timeout=30) | |
| if not resp.ok: | |
| logger.error(f"OpenRouter embeddings HTTP {resp.status_code}: {resp.text[:500]}") | |
| return None | |
| return resp.json() | |
| except Exception as e: | |
| logger.error(f"OpenRouter embeddings error: {e}") | |
| return None | |
| def embed(self, text: str) -> Optional[np.ndarray]: | |
| """Embed a single text string β 1024-dim numpy array.""" | |
| try: | |
| data = self._embed_via_openai(text, self._api_key) | |
| if not data: | |
| return None | |
| emb_list = data.get("data", [{}])[0].get("embedding") | |
| if not emb_list: | |
| logger.error("OpenRouter embeddings: empty result") | |
| return None | |
| return np.array(emb_list, dtype=np.float32) | |
| except Exception as e: | |
| logger.error(f"OpenRouter embed failed: {e}") | |
| return None | |
| def embed_batch(self, texts: List[str]) -> Optional[np.ndarray]: | |
| """Embed multiple texts β (N, 1024) numpy array.""" | |
| if not texts: | |
| return np.array([], dtype=np.float32).reshape(0, self.EMBEDDING_DIM) | |
| try: | |
| data = self._embed_via_openai(texts, self._api_key) | |
| if not data: | |
| return None | |
| items = data.get("data", []) | |
| vectors = [item.get("embedding", []) for item in items] | |
| if not vectors or not vectors[0]: | |
| logger.error("OpenRouter embeddings batch: empty result") | |
| return None | |
| return np.array(vectors, dtype=np.float32) | |
| except Exception as e: | |
| logger.error(f"OpenRouter embed_batch failed: {e}") | |
| return None | |
| # ============================================================ | |
| # TIER 2: Cloudflare Workers AI bge-m3 (free 10k/day) | |
| # ============================================================ | |
| class CloudflareEmbeddings: | |
| """ | |
| Cloudflare Workers AI bge-m3 β multilingual embedding model. | |
| 1024 dimensions, optimized for retrieval in 100+ languages. | |
| """ | |
| EMBEDDING_DIM = 1024 | |
| API_URL_TEMPLATE = "https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/run/@cf/baai/bge-m3" | |
| MIN_REQUEST_INTERVAL = 0.1 | |
| def __init__(self, account_id: Optional[str] = None, api_key: Optional[str] = None): | |
| self._account_id = account_id or os.getenv("CLOUDFLARE_ACCOUNT_ID") | |
| self._api_key = api_key or os.getenv("CLOUDFLARE_API_KEY") or os.getenv("CLOUDFALRE_API_KEY") | |
| self._last_request_time = 0.0 | |
| def is_available(self) -> bool: | |
| return bool(self._account_id and self._api_key) | |
| def _rate_limit(self): | |
| elapsed = time.time() - self._last_request_time | |
| if elapsed < self.MIN_REQUEST_INTERVAL: | |
| time.sleep(self.MIN_REQUEST_INTERVAL - elapsed) | |
| self._last_request_time = time.time() | |
| def _post(self, payload: dict) -> Optional[dict]: | |
| if not self.is_available(): | |
| return None | |
| self._rate_limit() | |
| url = self.API_URL_TEMPLATE.format(account_id=self._account_id) | |
| headers = {"Authorization": f"Bearer {self._api_key}", "Content-Type": "application/json"} | |
| try: | |
| resp = requests.post(url, headers=headers, json=payload, timeout=30) | |
| resp.raise_for_status() | |
| data = resp.json() | |
| if not data.get("success"): | |
| logger.error(f"Cloudflare API error: {data.get('errors', [])}") | |
| return None | |
| return data | |
| except Exception as e: | |
| logger.error(f"Cloudflare embeddings error: {e}") | |
| return None | |
| def embed(self, text: str) -> Optional[np.ndarray]: | |
| try: | |
| result = self._post({"input": text}) | |
| if not result: | |
| return None | |
| emb = result.get("result", {}).get("data") | |
| if not emb: | |
| return None | |
| return np.array(emb, dtype=np.float32) | |
| except Exception as e: | |
| logger.error(f"Cloudflare embed failed: {e}") | |
| return None | |
| def embed_batch(self, texts: List[str]) -> Optional[np.ndarray]: | |
| if not texts: | |
| return np.array([], dtype=np.float32).reshape(0, self.EMBEDDING_DIM) | |
| try: | |
| result = self._post({"input": texts}) | |
| if not result: | |
| return None | |
| data = result.get("result", {}).get("data") | |
| if not data: | |
| return None | |
| return np.array(data, dtype=np.float32) | |
| except Exception as e: | |
| logger.error(f"Cloudflare embed_batch failed: {e}") | |
| return None | |
| # ============================================================ | |
| # UNIFIED PROVIDER with 3-tier fallback | |
| # ============================================================ | |
| class RemoteEmbeddings: | |
| """ | |
| Unified embedding provider with automatic fallback: | |
| 1. OpenRouter Nemotron 3 Embed 1B (free, no limit) | |
| 2. Cloudflare bge-m3 (free 10k/day) | |
| 3. Returns None (caller uses SentenceTransformer local fallback) | |
| """ | |
| def __init__(self): | |
| self._openrouter = OpenRouterEmbeddings() | |
| self._cloudflare = CloudflareEmbeddings() | |
| self._active_provider = None | |
| self._init_provider() | |
| def _init_provider(self): | |
| if self._openrouter.is_available(): | |
| self._active_provider = "openrouter" | |
| logger.info("π€ [EMBEDDINGS] Tier 1: OpenRouter Nemotron 3 Embed 1B (free, no limit)") | |
| elif self._cloudflare.is_available(): | |
| self._active_provider = "cloudflare" | |
| logger.info("π€ [EMBEDDINGS] Tier 2: Cloudflare bge-m3 (free 10k/day)") | |
| else: | |
| self._active_provider = None | |
| logger.info("π€ [EMBEDDINGS] No remote provider β using SentenceTransformer local fallback") | |
| def is_available(self) -> bool: | |
| return self._active_provider is not None | |
| def embed(self, text: str) -> Optional[np.ndarray]: | |
| """Embed with automatic provider fallback.""" | |
| if self._active_provider == "openrouter": | |
| result = self._openrouter.embed(text) | |
| if result is not None: | |
| return result | |
| # Fallback to Cloudflare | |
| if self._cloudflare.is_available(): | |
| result = self._cloudflare.embed(text) | |
| if result is not None: | |
| self._active_provider = "cloudflare" | |
| return result | |
| return None | |
| if self._active_provider == "cloudflare": | |
| result = self._cloudflare.embed(text) | |
| if result is not None: | |
| return result | |
| # Fallback to OpenRouter if available | |
| if self._openrouter.is_available(): | |
| result = self._openrouter.embed(text) | |
| if result is not None: | |
| self._active_provider = "openrouter" | |
| return result | |
| return None | |
| return None | |
| def embed_batch(self, texts: List[str]) -> Optional[np.ndarray]: | |
| """Embed batch with automatic provider fallback.""" | |
| if not texts: | |
| return None | |
| if self._active_provider == "openrouter": | |
| result = self._openrouter.embed_batch(texts) | |
| if result is not None: | |
| return result | |
| if self._cloudflare.is_available(): | |
| result = self._cloudflare.embed_batch(texts) | |
| if result is not None: | |
| self._active_provider = "cloudflare" | |
| return result | |
| return None | |
| if self._active_provider == "cloudflare": | |
| result = self._cloudflare.embed_batch(texts) | |
| if result is not None: | |
| return result | |
| if self._openrouter.is_available(): | |
| result = self._openrouter.embed_batch(texts) | |
| if result is not None: | |
| self._active_provider = "openrouter" | |
| return result | |
| return None | |
| return None | |
| # ============================================================ | |
| # Singleton | |
| # ============================================================ | |
| _remote_embeddings_instance: Optional[RemoteEmbeddings] = None | |
| def get_remote_embeddings() -> RemoteEmbeddings: | |
| """Get or create the singleton RemoteEmbeddings instance.""" | |
| global _remote_embeddings_instance | |
| if _remote_embeddings_instance is None: | |
| _remote_embeddings_instance = RemoteEmbeddings() | |
| return _remote_embeddings_instance | |
| # Legacy alias | |
| def get_cloudflare_embeddings() -> RemoteEmbeddings: | |
| """Legacy alias β returns RemoteEmbeddings with fallback chain.""" | |
| return get_remote_embeddings() | |