mcp-agentic-pipelines 1.0.1

package/vendors/precis/backend/llm/factory.py

@@ -0,0 +1,60 @@
+"""© JINAN KORDAB — 2026 AI HYBRID AGENTIC RETRIEVAL-AUGMENTED GENERATION RAG PIPELINE - PERSONAL PROJECT"""
+
+from typing import Dict, Optional, Type
+from backend.llm.base import LLMProvider
+from backend.config import settings
+
+
+class LLMFactory:
+    """Central registry for LLM providers. Hot-swap by changing config."""
+
+    _providers: Dict[str, Type[LLMProvider]] = {}
+
+    @classmethod
+    def register(cls, name: str, provider_class: Type[LLMProvider]) -> None:
+        """Register a provider class. Called at startup for all 5 providers."""
+        cls._providers[name] = provider_class
+
+    @classmethod
+    def create(cls, name: str, **kwargs) -> LLMProvider:
+        """Create a provider instance by name. Raises ValueError if unknown."""
+        provider_class = cls._providers.get(name)
+        if provider_class is None:
+            available = list(cls._providers.keys())
+            raise ValueError(f"Unknown provider '{name}'. Available: {available}")
+        api_keys = {
+            "openai": settings.OPENAI_API_KEY, "anthropic": settings.ANTHROPIC_API_KEY,
+            "google": settings.GOOGLE_API_KEY, "deepseek": settings.DEEPSEEK_API_KEY,
+        }
+        api_key = api_keys.get(name)
+        if api_key and name != "ollama" and "api_key" not in kwargs:
+            return provider_class(api_key=api_key, **kwargs)
+        return provider_class(**kwargs)
+
+    @classmethod
+    def create_default(cls) -> LLMProvider:
+        """Create the default provider from config. Falls back to first available."""
+        name = settings.DEFAULT_LLM_PROVIDER
+        if name in cls._providers:
+            try:
+                return cls.create(name)
+            except Exception:
+                pass
+        for fallback in cls._providers:
+            try:
+                return cls.create(fallback)
+            except Exception:
+                continue
+        raise RuntimeError(f"No LLM provider available. Registered: {list(cls._providers.keys())}")
+
+    @classmethod
+    def create_with_fallback(cls, primary: str = "openai", fallback: str = "ollama") -> LLMProvider:
+        """Create primary provider, with automatic fallback on failure."""
+        try:
+            return cls.create(primary)
+        except Exception:
+            return cls.create(fallback)
+
+    @classmethod
+    def list_available(cls) -> list:
+        return list(cls._providers.keys())

package/vendors/precis/backend/llm/google_provider.py

@@ -0,0 +1,39 @@
+"""© JINAN KORDAB — 2026 AI HYBRID AGENTIC RETRIEVAL-AUGMENTED GENERATION RAG PIPELINE - PERSONAL PROJECT"""
+
+import asyncio
+from typing import AsyncGenerator, List, Optional
+import google.generativeai as genai
+from backend.llm.base import LLMProvider
+
+
+class GoogleProvider(LLMProvider):
+    def __init__(self, api_key: str, model: str = "gemini-1.5-pro") -> None:
+        genai.configure(api_key=api_key)
+        self._model_name = model
+        self._model = genai.GenerativeModel(self._model_name)
+
+    async def generate(self, prompt: str, system_prompt: Optional[str] = None,
+                       temperature: float = 0.7, max_tokens: int = 4096, **kwargs) -> str:
+        model = genai.GenerativeModel(self._model_name, system_instruction=system_prompt or None)
+        resp = await asyncio.to_thread(model.generate_content, prompt,
+            generation_config={"temperature": temperature, "max_output_tokens": max_tokens})
+        return resp.text or ""
+
+    async def generate_stream(self, prompt: str, system_prompt: Optional[str] = None,
+                              temperature: float = 0.7, max_tokens: int = 4096, **kwargs) -> AsyncGenerator[str, None]:
+        model = genai.GenerativeModel(self._model_name, system_instruction=system_prompt or None)
+        resp = await asyncio.to_thread(model.generate_content, prompt, stream=True,
+            generation_config={"temperature": temperature, "max_output_tokens": max_tokens})
+        for chunk in resp:
+            if chunk.text:
+                yield chunk.text
+
+    async def embed(self, texts: List[str], model: Optional[str] = None) -> List[List[float]]:
+        result = await asyncio.to_thread(genai.embed_content,
+            model=model or "models/text-embedding-004", content=texts)
+        return result.get("embedding", [[0.0]])
+
+    def get_model_name(self) -> str: return self._model_name
+
+    def get_token_count(self, text: str) -> int:
+        return self._model.count_tokens(text).total_tokens

package/vendors/precis/backend/llm/ollama_provider.py

@@ -0,0 +1,54 @@
+"""© JINAN KORDAB — 2026 AI HYBRID AGENTIC RETRIEVAL-AUGMENTED GENERATION RAG PIPELINE - PERSONAL PROJECT"""
+
+import json
+from typing import AsyncGenerator, List, Optional
+import httpx
+from backend.llm.base import LLMProvider
+
+
+class OllamaProvider(LLMProvider):
+    def __init__(self, base_url: str = "http://localhost:11434", model: str = "llama3") -> None:
+        self._base = base_url.rstrip("/")
+        self._model = model
+
+    async def _post(self, endpoint: str, data: dict) -> dict:
+        async with httpx.AsyncClient(timeout=120) as client:
+            resp = await client.post(f"{self._base}/api/{endpoint}", json=data)
+            return resp.json() if resp.status_code == 200 else {}
+
+    async def generate(self, prompt: str, system_prompt: Optional[str] = None,
+                       temperature: float = 0.7, max_tokens: int = 4096, **kwargs) -> str:
+        data = {"model": self._model, "prompt": prompt, "stream": False,
+                "options": {"temperature": temperature, "num_predict": max_tokens}}
+        if system_prompt:
+            data["system"] = system_prompt
+        result = await self._post("generate", data)
+        return result.get("response", "")
+
+    async def generate_stream(self, prompt: str, system_prompt: Optional[str] = None,
+                              temperature: float = 0.7, max_tokens: int = 4096, **kwargs) -> AsyncGenerator[str, None]:
+        data = {"model": self._model, "prompt": prompt, "stream": True,
+                "options": {"temperature": temperature, "num_predict": max_tokens}}
+        if system_prompt:
+            data["system"] = system_prompt
+        async with httpx.AsyncClient(timeout=300) as client:
+            async with client.stream("POST", f"{self._base}/api/generate", json=data) as resp:
+                async for line in resp.aiter_lines():
+                    if line:
+                        try:
+                            chunk = json.loads(line)
+                            if chunk.get("response"):
+                                yield chunk["response"]
+                        except json.JSONDecodeError:
+                            pass
+
+    async def embed(self, texts: List[str], model: Optional[str] = None) -> List[List[float]]:
+        embeddings = []
+        for text in texts:
+            result = await self._post("embeddings", {"model": model or "nomic-embed-text", "prompt": text})
+            embeddings.append(result.get("embedding", [0.0]))
+        return embeddings
+
+    def get_model_name(self) -> str: return self._model
+
+    def get_token_count(self, text: str) -> int: return len(text) // 4

package/vendors/precis/backend/llm/openai_provider.py

@@ -0,0 +1,50 @@
+"""© JINAN KORDAB — 2026 AI HYBRID AGENTIC RETRIEVAL-AUGMENTED GENERATION RAG PIPELINE - PERSONAL PROJECT"""
+
+from typing import AsyncGenerator, List, Optional
+from openai import AsyncOpenAI
+from backend.llm.base import LLMProvider
+
+
+class OpenAIProvider(LLMProvider):
+    def __init__(self, api_key: str, model: str = "gpt-4o", base_url: str = None) -> None:
+        self._client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+        self._model = model
+
+    async def generate(self, prompt: str, system_prompt: Optional[str] = None,
+                       temperature: float = 0.7, max_tokens: int = 4096, **kwargs) -> str:
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        resp = await self._client.chat.completions.create(
+            model=self._model, messages=messages, temperature=temperature,
+            max_tokens=max_tokens, **kwargs)
+        return resp.choices[0].message.content or ""
+
+    async def generate_stream(self, prompt: str, system_prompt: Optional[str] = None,
+                              temperature: float = 0.7, max_tokens: int = 4096, **kwargs) -> AsyncGenerator[str, None]:
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+        stream = await self._client.chat.completions.create(
+            model=self._model, messages=messages, temperature=temperature,
+            max_tokens=max_tokens, stream=True, **kwargs)
+        async for chunk in stream:
+            if chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
+
+    async def embed(self, texts: List[str], model: Optional[str] = None) -> List[List[float]]:
+        resp = await self._client.embeddings.create(
+            model=model or "text-embedding-3-small", input=texts)
+        return [d.embedding for d in resp.data]
+
+    def get_model_name(self) -> str: return self._model
+
+    def get_token_count(self, text: str) -> int:
+        try:
+            import tiktoken
+            enc = tiktoken.encoding_for_model(self._model)
+            return len(enc.encode(text))
+        except Exception:
+            return len(text) // 4