corellm-sdk 1.1.0__tar.gz

corellm_sdk-1.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: corellm-sdk
+Version: 1.1.0
+Summary: Python client for CoreLLM SDK — LLM gateway running Ollama on Hugging Face Spaces
+Author: Namit Kumar
+License: MIT
+Keywords: llm,ollama,langchain,langgraph,huggingface,ai,corellm-sdk
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: langchain-core>=0.2
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.2; extra == "langchain"
+Requires-Dist: langchain-core>=0.2; extra == "langchain"
+Provides-Extra: all
+Requires-Dist: langchain>=0.2; extra == "all"
+Requires-Dist: langchain-core>=0.2; extra == "all"
+Requires-Dist: langgraph>=0.1; extra == "all"
+
+---
+title: CoreLLM SDK
+emoji: 🧠
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+# CoreLLM SDK
+
+A fully-featured Python client and Hugging Face Space for running LLMs via Ollama — with native LangChain & LangGraph support. 
+
+`corellm-sdk` acts as an all-in-one unified model interface!
+
+## 📦 Install from PyPI
+
+```bash
+# Minimal installation (just the client)
+pip install corellm-sdk
+
+# With LangChain support
+pip install "corellm-sdk[langchain]"
+
+# With LangChain + LangGraph support
+pip install "corellm-sdk[all]"
+```
+
+## 🤖 Available Models
+
+The following models are available on the server. **Do not use any other model names.**
+- `"gemma4:e4b"` - text, vision, tools, thinking, audio, context=128k
+- `"devstral:24b"` - text, tools, context=128k
+- `"cogito:14b"` - text, tools, thinking, context=128k
+- `"ornith:9b"` - Text, thinking, tools, context=256k
+- `"lfm2.5-thinking:1.2b"` - ultra fast, tools, thinking, context=32k
+- `"qwen3-embedding:8b"` - embedding
+- `"robit/ornith-vision:9b"` - vision, tools, thinking
+
+## 🚀 Quickstart
+
+The new **CoreLLMChat** class wraps everything into a single, cohesive, Langchain-compatible chat model that also handles normal chat generation, raw completion, and OpenAI compatibility.
+
+```python
+from corellm_sdk import CoreLLMChat
+
+# Initialize the engine
+llm = CoreLLMChat(
+    model="gemma4:e4b"
+)
+```
+
+## 🧩 LangChain & LangGraph Support
+
+Use it seamlessly with your existing LangChain workflows:
+
+```python
+from langchain_core.messages import HumanMessage
+from langchain_core.prompts import ChatPromptTemplate
+
+# Direct usage
+response = llm.invoke([HumanMessage(content="Hello!")])
+print(response.content)
+
+# With Chains
+chain = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant."),
+    ("human", "{question}"),
+]) | llm
+
+print(chain.invoke({"question": "What is Python?"}).content)
+```
+
+## 💬 OpenAI Compatibility (`openai_chat`)
+
+Have existing code using OpenAI structures? Just use the OpenAI method out of the box!
+
+```python
+messages = [
+    {"role": "system", "content": "You are a witty assistant."},
+    {"role": "user", "content": "Tell me a joke."}
+]
+
+# Calls the /v1/chat/completions endpoint just like OpenAI
+response = llm.openai_chat(messages, temperature=0.7)
+print(response)
+```
+
+## 🛠 Raw APIs (`raw_chat` & `generate`)
+
+If you want simpler formats:
+
+```python
+# Raw Prompt Completion
+print(llm.generate("Explain quantum physics in 1 sentence."))
+
+# Standard Dict Chat
+messages = [{"role": "user", "content": "Who are you?"}]
+print(llm.raw_chat(messages))
+```
+
+## 🔄 Dynamic Model Switching
+Switch models on the fly! The backend dynamically handles memory constraints and load transitions.
+
+```python
+# Switch to another allowed model on your server!
+llm.switch("devstral:24b")
+
+print(llm.generate("Hello from Devstral!"))
+```

corellm_sdk-1.1.0/README.md

@@ -0,0 +1,110 @@
+---
+title: CoreLLM SDK
+emoji: 🧠
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+# CoreLLM SDK
+
+A fully-featured Python client and Hugging Face Space for running LLMs via Ollama — with native LangChain & LangGraph support. 
+
+`corellm-sdk` acts as an all-in-one unified model interface!
+
+## 📦 Install from PyPI
+
+```bash
+# Minimal installation (just the client)
+pip install corellm-sdk
+
+# With LangChain support
+pip install "corellm-sdk[langchain]"
+
+# With LangChain + LangGraph support
+pip install "corellm-sdk[all]"
+```
+
+## 🤖 Available Models
+
+The following models are available on the server. **Do not use any other model names.**
+- `"gemma4:e4b"` - text, vision, tools, thinking, audio, context=128k
+- `"devstral:24b"` - text, tools, context=128k
+- `"cogito:14b"` - text, tools, thinking, context=128k
+- `"ornith:9b"` - Text, thinking, tools, context=256k
+- `"lfm2.5-thinking:1.2b"` - ultra fast, tools, thinking, context=32k
+- `"qwen3-embedding:8b"` - embedding
+- `"robit/ornith-vision:9b"` - vision, tools, thinking
+
+## 🚀 Quickstart
+
+The new **CoreLLMChat** class wraps everything into a single, cohesive, Langchain-compatible chat model that also handles normal chat generation, raw completion, and OpenAI compatibility.
+
+```python
+from corellm_sdk import CoreLLMChat
+
+# Initialize the engine
+llm = CoreLLMChat(
+    model="gemma4:e4b"
+)
+```
+
+## 🧩 LangChain & LangGraph Support
+
+Use it seamlessly with your existing LangChain workflows:
+
+```python
+from langchain_core.messages import HumanMessage
+from langchain_core.prompts import ChatPromptTemplate
+
+# Direct usage
+response = llm.invoke([HumanMessage(content="Hello!")])
+print(response.content)
+
+# With Chains
+chain = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant."),
+    ("human", "{question}"),
+]) | llm
+
+print(chain.invoke({"question": "What is Python?"}).content)
+```
+
+## 💬 OpenAI Compatibility (`openai_chat`)
+
+Have existing code using OpenAI structures? Just use the OpenAI method out of the box!
+
+```python
+messages = [
+    {"role": "system", "content": "You are a witty assistant."},
+    {"role": "user", "content": "Tell me a joke."}
+]
+
+# Calls the /v1/chat/completions endpoint just like OpenAI
+response = llm.openai_chat(messages, temperature=0.7)
+print(response)
+```
+
+## 🛠 Raw APIs (`raw_chat` & `generate`)
+
+If you want simpler formats:
+
+```python
+# Raw Prompt Completion
+print(llm.generate("Explain quantum physics in 1 sentence."))
+
+# Standard Dict Chat
+messages = [{"role": "user", "content": "Who are you?"}]
+print(llm.raw_chat(messages))
+```
+
+## 🔄 Dynamic Model Switching
+Switch models on the fly! The backend dynamically handles memory constraints and load transitions.
+
+```python
+# Switch to another allowed model on your server!
+llm.switch("devstral:24b")
+
+print(llm.generate("Hello from Devstral!"))
+```

corellm_sdk-1.1.0/corellm_sdk.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: corellm-sdk
+Version: 1.1.0
+Summary: Python client for CoreLLM SDK — LLM gateway running Ollama on Hugging Face Spaces
+Author: Namit Kumar
+License: MIT
+Keywords: llm,ollama,langchain,langgraph,huggingface,ai,corellm-sdk
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: langchain-core>=0.2
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.2; extra == "langchain"
+Requires-Dist: langchain-core>=0.2; extra == "langchain"
+Provides-Extra: all
+Requires-Dist: langchain>=0.2; extra == "all"
+Requires-Dist: langchain-core>=0.2; extra == "all"
+Requires-Dist: langgraph>=0.1; extra == "all"
+
+---
+title: CoreLLM SDK
+emoji: 🧠
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+# CoreLLM SDK
+
+A fully-featured Python client and Hugging Face Space for running LLMs via Ollama — with native LangChain & LangGraph support. 
+
+`corellm-sdk` acts as an all-in-one unified model interface!
+
+## 📦 Install from PyPI
+
+```bash
+# Minimal installation (just the client)
+pip install corellm-sdk
+
+# With LangChain support
+pip install "corellm-sdk[langchain]"
+
+# With LangChain + LangGraph support
+pip install "corellm-sdk[all]"
+```
+
+## 🤖 Available Models
+
+The following models are available on the server. **Do not use any other model names.**
+- `"gemma4:e4b"` - text, vision, tools, thinking, audio, context=128k
+- `"devstral:24b"` - text, tools, context=128k
+- `"cogito:14b"` - text, tools, thinking, context=128k
+- `"ornith:9b"` - Text, thinking, tools, context=256k
+- `"lfm2.5-thinking:1.2b"` - ultra fast, tools, thinking, context=32k
+- `"qwen3-embedding:8b"` - embedding
+- `"robit/ornith-vision:9b"` - vision, tools, thinking
+
+## 🚀 Quickstart
+
+The new **CoreLLMChat** class wraps everything into a single, cohesive, Langchain-compatible chat model that also handles normal chat generation, raw completion, and OpenAI compatibility.
+
+```python
+from corellm_sdk import CoreLLMChat
+
+# Initialize the engine
+llm = CoreLLMChat(
+    model="gemma4:e4b"
+)
+```
+
+## 🧩 LangChain & LangGraph Support
+
+Use it seamlessly with your existing LangChain workflows:
+
+```python
+from langchain_core.messages import HumanMessage
+from langchain_core.prompts import ChatPromptTemplate
+
+# Direct usage
+response = llm.invoke([HumanMessage(content="Hello!")])
+print(response.content)
+
+# With Chains
+chain = ChatPromptTemplate.from_messages([
+    ("system", "You are a helpful assistant."),
+    ("human", "{question}"),
+]) | llm
+
+print(chain.invoke({"question": "What is Python?"}).content)
+```
+
+## 💬 OpenAI Compatibility (`openai_chat`)
+
+Have existing code using OpenAI structures? Just use the OpenAI method out of the box!
+
+```python
+messages = [
+    {"role": "system", "content": "You are a witty assistant."},
+    {"role": "user", "content": "Tell me a joke."}
+]
+
+# Calls the /v1/chat/completions endpoint just like OpenAI
+response = llm.openai_chat(messages, temperature=0.7)
+print(response)
+```
+
+## 🛠 Raw APIs (`raw_chat` & `generate`)
+
+If you want simpler formats:
+
+```python
+# Raw Prompt Completion
+print(llm.generate("Explain quantum physics in 1 sentence."))
+
+# Standard Dict Chat
+messages = [{"role": "user", "content": "Who are you?"}]
+print(llm.raw_chat(messages))
+```
+
+## 🔄 Dynamic Model Switching
+Switch models on the fly! The backend dynamically handles memory constraints and load transitions.
+
+```python
+# Switch to another allowed model on your server!
+llm.switch("devstral:24b")
+
+print(llm.generate("Hello from Devstral!"))
+```

corellm_sdk-1.1.0/corellm_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+corellm_sdk.py
+pyproject.toml
+corellm_sdk.egg-info/PKG-INFO
+corellm_sdk.egg-info/SOURCES.txt
+corellm_sdk.egg-info/dependency_links.txt
+corellm_sdk.egg-info/requires.txt
+corellm_sdk.egg-info/top_level.txt

corellm_sdk-1.1.0/corellm_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

corellm_sdk-1.1.0/corellm_sdk.egg-info/requires.txt

@@ -0,0 +1,11 @@
+httpx>=0.27
+langchain-core>=0.2
+
+[all]
+langchain>=0.2
+langchain-core>=0.2
+langgraph>=0.1
+
+[langchain]
+langchain>=0.2
+langchain-core>=0.2

corellm_sdk-1.1.0/corellm_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+corellm_sdk

corellm_sdk-1.1.0/corellm_sdk.py

@@ -0,0 +1,196 @@
+"""
+CoreLLM SDK Python Client
+=========================
+A LangChain-native chat model client for your CoreLLM Hugging Face Space.
+
+Usage
+-----
+    from corellm_sdk import CoreLLMChat
+    from langchain_core.messages import HumanMessage
+    
+    llm = CoreLLMChat(
+        model="gemma4:e4b"
+    )
+    
+    # LangChain usage
+    response = llm.invoke([HumanMessage(content="Hello!")])
+    print(response.content)
+    
+    # OpenAI format usage
+    response = llm.openai_chat([{"role": "user", "content": "Hello!"}])
+    print(response)
+"""
+
+from __future__ import annotations
+
+import os
+import httpx
+from typing import Optional, Any, List, Mapping, Dict
+
+# pyrefly: ignore [missing-import]
+from langchain_core.language_models.chat_models import BaseChatModel
+# pyrefly: ignore [missing-import]
+from langchain_core.messages import BaseMessage, AIMessage
+# pyrefly: ignore [missing-import]
+from langchain_core.outputs import ChatGeneration, ChatResult
+# pyrefly: ignore [missing-import]
+from langchain_core.callbacks import CallbackManagerForLLMRun
+
+
+class CoreLLMChat(BaseChatModel):
+    """
+    LangChain-compatible chat model backed by your CoreLLM HF Space.
+
+    Drop-in replacement for ChatOpenAI — use it in any LangChain
+    chain or LangGraph graph. Also includes raw OpenAI compatibility methods.
+    
+    Parameters
+    ----------
+    model : str
+        The model to use (must be in server's ALLOWED_MODELS).
+    base_url : str, optional
+        Your CoreLLM Space URL. Defaults to the public HF Space endpoint.
+    preload : bool
+        Pre-warm the model on init (default True).
+    timeout : int
+        Request timeout seconds (default 300).
+    """
+
+    model: str
+    base_url: str = "https://namitkumar22-corellm.hf.space"
+    preload: bool = True
+    timeout: int = 300
+
+    def model_post_init(self, __context: Any) -> None:
+        """Called automatically after __init__ by pydantic v2."""
+        # Need to re-assign properly if missing
+        base = self.base_url or os.environ.get("CORELLM_BASE_URL", "https://namitkumar22-corellm.hf.space")
+        self.base_url = base.rstrip("/")
+
+        if self.preload:
+            self._preload(self.model)
+
+    @property
+    def _llm_type(self) -> str:
+        return "corellm_sdk"
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        return {"model": self.model, "base_url": self.base_url}
+
+    # ── Internals ─────────────────────────────────────────────────────────────
+
+    @property
+    def _headers(self) -> dict:
+        return {"Content-Type": "application/json"}
+
+    def _post(self, path: str, body: dict) -> dict:
+        with httpx.Client(timeout=self.timeout) as client:
+            r = client.post(f"{self.base_url}{path}", json=body, headers=self._headers)
+            r.raise_for_status()
+            return r.json()
+
+    def _get(self, path: str) -> dict:
+        with httpx.Client(timeout=self.timeout) as client:
+            r = client.get(f"{self.base_url}{path}", headers=self._headers)
+            r.raise_for_status()
+            return r.json()
+
+    def _preload(self, model: str):
+        print(f"[CoreLLM SDK] Pre-warming '{model}' on server...")
+        try:
+            self._post("/api/load", {"model": model})
+            print(f"[CoreLLM SDK] ✓ '{model}' is ready.")
+        except Exception as e:
+            print(f"[CoreLLM SDK] Failed to pre-warm model: {e}")
+
+    # ── Model control ─────────────────────────────────────────────────────────
+
+    def switch(self, new_model: str) -> "CoreLLMChat":
+        """
+        Switch the active model on the server and update this instance.
+        Previous model is unloaded from RAM automatically.
+        """
+        print(f"[CoreLLM SDK] Switching '{self.model}' → '{new_model}'...")
+        self._post("/api/switch", {"model": new_model})
+        self.model = new_model
+        print(f"[CoreLLM SDK] ✓ Active model is now '{new_model}'.")
+        return self
+
+    def unload(self) -> dict:
+        """Release the current model from server RAM."""
+        result = self._post("/api/unload", {"model": self.model})
+        print(f"[CoreLLM SDK] '{self.model}' unloaded from memory.")
+        return result
+        
+    def list_models(self) -> list[str]:
+        """Return all models available on the server."""
+        return self._get("/api/models").get("models", [])
+
+    def status(self) -> dict:
+        """Return server health and active model info."""
+        return self._get("/")
+
+    # ── LangChain Core ────────────────────────────────────────────────────────
+
+    def _convert_messages(self, messages: List[BaseMessage]) -> List[dict]:
+        role_map = {
+            "human": "user",
+            "ai": "assistant",
+            "system": "system",
+            "function": "function",
+            "tool": "tool",
+        }
+        result = []
+        for m in messages:
+            role = role_map.get(m.type, m.type)
+            result.append({"role": role, "content": str(m.content)})
+        return result
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        msg_dicts = self._convert_messages(messages)
+        extra = {}
+        if stop:
+            extra["stop"] = stop
+
+        content = self.raw_chat(msg_dicts, **extra, **kwargs)
+        message = AIMessage(content=content)
+        return ChatResult(generations=[ChatGeneration(message=message)])
+
+    # ── Additional Inference Endpoints ────────────────────────────────────────
+
+    def raw_chat(self, messages: list[dict], **kwargs) -> str:
+        """
+        Multi-turn chat using the Ollama /api/chat endpoint.
+        """
+        body = {"model": self.model, "messages": messages, "stream": False, **kwargs}
+        result = self._post("/api/chat", body)
+        return result.get("message", {}).get("content", "")
+
+    def generate(self, prompt: str, **kwargs) -> str:
+        """
+        Raw text completion using the Ollama /api/generate endpoint.
+        """
+        body = {"model": self.model, "prompt": prompt, "stream": False, **kwargs}
+        result = self._post("/api/generate", body)
+        return result.get("response", "")
+
+    def openai_chat(self, messages: list[dict], **kwargs) -> str:
+        """
+        OpenAI-compatible /v1/chat/completions endpoint.
+        Compatible with any tool expecting the OpenAI response format.
+        
+        Returns the raw string content.
+        """
+        body = {"model": self.model, "messages": messages, **kwargs}
+        result = self._post("/v1/chat/completions", body)
+        try:
+            return result["choices"][0]["message"]["content"]
+        except (KeyError, IndexError):
+            return str(result)

corellm_sdk-1.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "corellm-sdk"
+version = "1.1.0"
+description = "Python client for CoreLLM SDK — LLM gateway running Ollama on Hugging Face Spaces"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Namit Kumar" }]
+
+keywords = ["llm", "ollama", "langchain", "langgraph", "huggingface", "ai", "corellm-sdk"]
+
+dependencies = [
+    "httpx>=0.27",
+    "langchain-core>=0.2",
+]
+
+[project.optional-dependencies]
+# pip install corellm-sdk[langchain]
+langchain = [
+    "langchain>=0.2",
+    "langchain-core>=0.2",
+]
+# pip install corellm-sdk[all]
+all = [
+    "langchain>=0.2",
+    "langchain-core>=0.2",
+    "langgraph>=0.1",
+]
+
+[tool.setuptools]
+# corellm_sdk.py is a single-file module at the root
+py-modules = ["corellm_sdk"]

corellm_sdk-1.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+