lightmodel 0.1.4__tar.gz → 0.3.0__tar.gz

{lightmodel-0.1.4 → lightmodel-0.3.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Your Name
+Copyright (c) 2026 PlimbAI
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

lightmodel-0.3.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: lightmodel
+Version: 0.3.0
+Summary: Ultra-light autonomous AI agents for any OpenAI-compatible API
+Author-email: PlimbAI <plimb.ai.contact@gmail.com>
+License-Expression: MIT
+Keywords: llm,ai,agent,openai,nvidia-nim,tool-calling,no-dependencies
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: search
+Requires-Dist: beautifulsoup4>=4.12; extra == "search"
+Dynamic: license-file
+
+# LightModel
+
+Ultra-light **autonomous AI agents** for any OpenAI-compatible API.
+No `smolagents`, no `litellm`, no `openai` — just `requests`.
+
+## Features
+
+- `LightModel`: HTTP client with automatic retry on transient errors
+- `Agent`: autonomous tool-calling loop with parallel tools and callbacks
+- Built-in tools: `web_search`, `visit_webpage`, `calculator`
+- Extensible: add a tool by subclassing `Tool`
+- Zero heavy dependencies
+
+## Installation
+
+    pip install lightmodel
+    pip install lightmodel[search]   # with beautifulsoup4 for web tools
+
+## Quick start
+
+    from lightmodel import Agent, LightModel, SimpleDuckDuckGoSearchTool
+
+    model = LightModel(
+        model_id="meta/llama-3.3-70b-instruct",
+        api_base="https://integrate.api.nvidia.com/v1",
+        api_key="your_key",
+    )
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        system_prompt="You are a helpful research assistant.",
+        max_steps=6,
+        verbose=True,
+    )
+    print(agent.run("What are the latest AI news in 2026?"))
+
+## Multi-turn conversation
+
+    print(agent.chat("Tell me more about the first result."))
+    print(agent.chat("Summarize in one sentence."))
+
+## Custom tools
+
+    from lightmodel import Tool
+
+    class CalculatorTool(Tool):
+        name = "calculator"
+        description = "Evaluate arithmetic."
+        inputs = {"expression": {"type": "string", "description": "e.g. 2+2"}}
+
+        def forward(self, expression):
+            return str(eval(expression, {"__builtins__": {}}, {}))
+
+## Callbacks
+
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        callbacks={
+            "on_step": lambda step, msg: print(f"step {step}"),
+            "on_tool_call": lambda name, args: print(f"→ {name}({args})"),
+            "on_tool_result": lambda name, result: print(f"← {result[:80]}"),
+            "on_final": lambda answer: print(f"✓ done"),
+            "on_error": lambda exc: print(f"✗ {exc}"),
+        },
+    )
+
+## Streaming
+
+    for chunk in model.stream_chat([{"role": "user", "content": "Hi"}]):
+        print(chunk, end="", flush=True)
+
+## License
+
+MIT

lightmodel-0.3.0/README.md

@@ -0,0 +1,75 @@
+# LightModel
+
+Ultra-light **autonomous AI agents** for any OpenAI-compatible API.
+No `smolagents`, no `litellm`, no `openai` — just `requests`.
+
+## Features
+
+- `LightModel`: HTTP client with automatic retry on transient errors
+- `Agent`: autonomous tool-calling loop with parallel tools and callbacks
+- Built-in tools: `web_search`, `visit_webpage`, `calculator`
+- Extensible: add a tool by subclassing `Tool`
+- Zero heavy dependencies
+
+## Installation
+
+    pip install lightmodel
+    pip install lightmodel[search]   # with beautifulsoup4 for web tools
+
+## Quick start
+
+    from lightmodel import Agent, LightModel, SimpleDuckDuckGoSearchTool
+
+    model = LightModel(
+        model_id="meta/llama-3.3-70b-instruct",
+        api_base="https://integrate.api.nvidia.com/v1",
+        api_key="your_key",
+    )
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        system_prompt="You are a helpful research assistant.",
+        max_steps=6,
+        verbose=True,
+    )
+    print(agent.run("What are the latest AI news in 2026?"))
+
+## Multi-turn conversation
+
+    print(agent.chat("Tell me more about the first result."))
+    print(agent.chat("Summarize in one sentence."))
+
+## Custom tools
+
+    from lightmodel import Tool
+
+    class CalculatorTool(Tool):
+        name = "calculator"
+        description = "Evaluate arithmetic."
+        inputs = {"expression": {"type": "string", "description": "e.g. 2+2"}}
+
+        def forward(self, expression):
+            return str(eval(expression, {"__builtins__": {}}, {}))
+
+## Callbacks
+
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        callbacks={
+            "on_step": lambda step, msg: print(f"step {step}"),
+            "on_tool_call": lambda name, args: print(f"→ {name}({args})"),
+            "on_tool_result": lambda name, result: print(f"← {result[:80]}"),
+            "on_final": lambda answer: print(f"✓ done"),
+            "on_error": lambda exc: print(f"✗ {exc}"),
+        },
+    )
+
+## Streaming
+
+    for chunk in model.stream_chat([{"role": "user", "content": "Hi"}]):
+        print(chunk, end="", flush=True)
+
+## License
+
+MIT

{lightmodel-0.1.4 → lightmodel-0.3.0}/pyproject.toml

@@ -4,22 +4,20 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lightmodel"
-version = "0.1.4"
-description = "Ultra-light Model adapter and web search tool for smolagents - works with any OpenAI-compatible API"
+version = "0.3.0"
+description = "Ultra-light autonomous AI agents for any OpenAI-compatible API"
 readme = "README.md"
 requires-python = ">=3.9"
-license = {text = "MIT"}
-authors = [{name = "PlimbAi", email = "plimb.ai.contact@gmail.com"}]
-keywords = ["smolagents", "llm", "ai", "agent", "openai", "nvidia-nim", "duckduckgo", "web-search"]
+license = "MIT"
+authors = [{name = "PlimbAI", email = "plimb.ai.contact@gmail.com"}]
+keywords = ["llm", "ai", "agent", "openai", "nvidia-nim", "tool-calling", "no-dependencies"]
 classifiers = [
     "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
 dependencies = ["requests>=2.28"]
 
 [project.optional-dependencies]
-smolagents = ["smolagents>=1.0"]
 search = ["beautifulsoup4>=4.12"]
 
 [tool.setuptools.packages.find]

lightmodel-0.3.0/src/lightmodel/__init__.py

@@ -0,0 +1,12 @@
+"""LightModel - Ultra-light autonomous AI agents."""
+from .model import LightModel
+from .tools import Tool, SimpleDuckDuckGoSearchTool, CalculatorTool, VisitWebpageTool
+from .agent import Agent
+from .exceptions import LightModelError, APIError, ToolError, MaxStepsError
+
+__version__ = "0.3.0"
+__all__ = [
+    "LightModel", "Agent",
+    "Tool", "SimpleDuckDuckGoSearchTool", "CalculatorTool", "VisitWebpageTool",
+    "LightModelError", "APIError", "ToolError", "MaxStepsError",
+]

lightmodel-0.3.0/src/lightmodel/agent.py

@@ -0,0 +1,134 @@
+"""LightModel Agent - autonomous tool-calling loop."""
+import json
+import logging
+import concurrent.futures
+
+from .exceptions import MaxStepsError
+
+logger = logging.getLogger(__name__)
+
+
+class Agent:
+    """Autonomous agent using native OpenAI tool calling."""
+
+    def __init__(self, model, tools=None, system_prompt=None,
+                 max_steps=10, verbose=False, parallel_tools=True,
+                 callbacks=None, raise_on_max_steps=False):
+        self.model = model
+        self.tools = {t.name: t for t in (tools or [])}
+        self.system_prompt = system_prompt
+        self.max_steps = max_steps
+        self.verbose = verbose
+        self.parallel_tools = parallel_tools
+        self.callbacks = callbacks or {}
+        self.raise_on_max_steps = raise_on_max_steps
+        self.messages = []
+        self.reset()
+
+    def reset(self):
+        """Clear conversation history (keeps system prompt)."""
+        self.messages = []
+        if self.system_prompt:
+            self.messages.append({"role": "system", "content": self.system_prompt})
+
+    def _cb(self, name, *args):
+        fn = self.callbacks.get(name)
+        if fn:
+            try:
+                fn(*args)
+            except Exception:
+                logger.exception("Callback %s failed", name)
+
+    def _log(self, msg):
+        if self.verbose:
+            print(msg)
+
+    def run(self, task, reset=True):
+        """Execute a task and return the final text answer."""
+        if reset:
+            self.reset()
+        self.messages.append({"role": "user", "content": task})
+        return self._loop()
+
+    def chat(self, message, reset=False):
+        """Continue the conversation with a new message."""
+        if reset:
+            self.reset()
+        self.messages.append({"role": "user", "content": message})
+        return self._loop()
+
+    def _loop(self):
+        openai_tools = [t.to_openai() for t in self.tools.values()] or None
+
+        for step in range(1, self.max_steps + 1):
+            try:
+                msg = self.model.chat(self.messages, tools=openai_tools)
+            except Exception as e:
+                self._cb("on_error", e)
+                raise
+
+            self._cb("on_step", step, msg)
+
+            assistant = {"role": "assistant"}
+            if msg.get("content"):
+                assistant["content"] = msg["content"]
+            if msg.get("tool_calls"):
+                assistant["tool_calls"] = msg["tool_calls"]
+            self.messages.append(assistant)
+
+            tool_calls = msg.get("tool_calls") or []
+            if not tool_calls:
+                final = msg.get("content") or ""
+                self._cb("on_final", final)
+                return final
+
+            self._log(f"[step {step}] {len(tool_calls)} tool call(s)")
+
+            if self.parallel_tools and len(tool_calls) > 1:
+                with concurrent.futures.ThreadPoolExecutor(
+                        max_workers=len(tool_calls)) as ex:
+                    results = list(ex.map(self._run_tool, tool_calls))
+            else:
+                results = [self._run_tool(tc) for tc in tool_calls]
+
+            for tc, result in zip(tool_calls, results):
+                self.messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "content": result,
+                })
+
+        err = MaxStepsError(
+            f"Reached {self.max_steps} steps without a final answer"
+        )
+        self._cb("on_error", err)
+        if self.raise_on_max_steps:
+            raise err
+        return str(err)
+
+    def _run_tool(self, tc):
+        name = tc["function"]["name"]
+        raw_args = tc["function"]["arguments"]
+        try:
+            args = json.loads(raw_args) if isinstance(raw_args, str) else raw_args
+            if not isinstance(args, dict):
+                args = {}
+        except json.JSONDecodeError:
+            args = {}
+
+        self._log(f"  → {name}({args})")
+        self._cb("on_tool_call", name, args)
+
+        tool = self.tools.get(name)
+        if tool is None:
+            result = f"Unknown tool: {name}"
+        else:
+            try:
+                result = str(tool.forward(**args))
+            except Exception as e:
+                result = f"Tool error ({name}): {e}"
+
+        preview = result[:120].replace("\n", " ")
+        self._log(f"  ← {preview}...")
+        self._cb("on_tool_result", name, result)
+        return result

lightmodel-0.3.0/src/lightmodel/exceptions.py

@@ -0,0 +1,22 @@
+"""Custom exceptions for lightmodel."""
+
+
+class LightModelError(Exception):
+    """Base exception for all lightmodel errors."""
+
+
+class APIError(LightModelError):
+    """Raised when the API returns an HTTP error."""
+
+    def __init__(self, status, message, body=None):
+        self.status = status
+        self.body = body
+        super().__init__(f"API {status}: {message}")
+
+
+class ToolError(LightModelError):
+    """Raised when a tool fails to execute."""
+
+
+class MaxStepsError(LightModelError):
+    """Raised when the agent reaches max_steps without a final answer."""

lightmodel-0.3.0/src/lightmodel/model.py

@@ -0,0 +1,126 @@
+"""LightModel - pure HTTP client for OpenAI-compatible APIs."""
+import json
+import time
+import logging
+import requests
+
+from .exceptions import APIError
+
+logger = logging.getLogger(__name__)
+
+
+class LightModel:
+    """Client for any OpenAI-compatible /chat/completions API."""
+
+    RETRIABLE_STATUS = {429, 500, 502, 503, 504}
+
+    def __init__(self, model_id, api_base, api_key="not-needed",
+                 temperature=0.7, max_tokens=2048, timeout=120,
+                 max_retries=3, retry_backoff=2.0, extra=None, headers=None):
+        self.model_id = model_id
+        base = api_base.rstrip("/")
+        if not base.endswith("/chat/completions"):
+            base += "/chat/completions"
+        self.api_url = base
+        self.api_key = api_key
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.retry_backoff = retry_backoff
+        self.extra = extra or {}
+        self.headers = headers or {}
+
+    def __repr__(self):
+        return f"LightModel({self.model_id!r} @ {self.api_url!r})"
+
+    def _headers(self):
+        h = {"Content-Type": "application/json"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        h.update(self.headers)
+        return h
+
+    def _payload(self, messages, tools=None, stream=False, **overrides):
+        payload = {
+            "model": self.model_id,
+            "messages": messages,
+            "temperature": overrides.get("temperature", self.temperature),
+            "max_tokens": overrides.get("max_tokens", self.max_tokens),
+            **self.extra,
+        }
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = overrides.get("tool_choice", "auto")
+        if "response_format" in overrides:
+            payload["response_format"] = overrides["response_format"]
+        if stream:
+            payload["stream"] = True
+        return payload
+
+    def chat(self, messages, tools=None, **overrides):
+        """Send messages and return the assistant message dict (with retry)."""
+        last_exc = None
+        for attempt in range(self.max_retries + 1):
+            try:
+                return self._do_chat(messages, tools, **overrides)
+            except APIError as e:
+                if e.status not in self.RETRIABLE_STATUS:
+                    raise
+                last_exc = e
+                if attempt < self.max_retries:
+                    wait = self.retry_backoff ** attempt
+                    logger.warning("API %s, retrying in %.1fs", e.status, wait)
+                    time.sleep(wait)
+        raise last_exc
+
+    def _do_chat(self, messages, tools, **overrides):
+        r = requests.post(
+            self.api_url,
+            json=self._payload(messages, tools, **overrides),
+            headers=self._headers(),
+            timeout=self.timeout,
+        )
+        if r.status_code >= 400:
+            raise APIError(r.status_code, r.text[:300], body=r.text)
+        try:
+            return r.json()["choices"][0]["message"]
+        except Exception as e:
+            raise APIError(r.status_code, f"Invalid response: {r.text[:300]}") from e
+
+    def stream_chat(self, messages, tools=None, **overrides):
+        """Yield content chunks as they arrive (streaming)."""
+        r = requests.post(
+            self.api_url,
+            json=self._payload(messages, tools, stream=True, **overrides),
+            headers=self._headers(),
+            timeout=self.timeout,
+            stream=True,
+        )
+        if r.status_code >= 400:
+            raise APIError(r.status_code, r.text[:300])
+        for line in r.iter_lines():
+            if not line:
+                continue
+            line = line.decode("utf-8")
+            if not line.startswith("data: "):
+                continue
+            data = line[6:]
+            if data == "[DONE]":
+                break
+            try:
+                chunk = json.loads(data)
+                delta = chunk["choices"][0].get("delta", {})
+                content = delta.get("content")
+                if content:
+                    yield content
+            except (json.JSONDecodeError, KeyError, IndexError):
+                continue
+
+    def list_models(self):
+        """Return available model IDs (best-effort, server may not support it)."""
+        base = self.api_url.rsplit("/chat/completions", 1)[0]
+        r = requests.get(f"{base}/models", headers=self._headers(), timeout=30)
+        if r.status_code >= 400:
+            raise APIError(r.status_code, r.text[:200])
+        return [m["id"] for m in r.json().get("data", [])]

lightmodel-0.3.0/src/lightmodel/tools.py

@@ -0,0 +1,123 @@
+"""Lightweight tools for LightModel agents."""
+import requests
+
+
+def _get_bs4():
+    try:
+        from bs4 import BeautifulSoup
+        return BeautifulSoup
+    except ImportError:
+        raise ImportError(
+            "beautifulsoup4 is required: pip install 'lightmodel[search]'"
+        )
+
+
+class Tool:
+    """Base class for all tools. Subclass and override forward()."""
+
+    name = ""
+    description = ""
+    inputs = {}
+
+    def forward(self, **kwargs):
+        raise NotImplementedError
+
+    def to_openai(self):
+        props, required = {}, []
+        for name, spec in self.inputs.items():
+            props[name] = {
+                "type": spec.get("type", "string"),
+                "description": spec.get("description", ""),
+            }
+            required.append(name)
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": props,
+                    "required": required,
+                },
+            },
+        }
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} name={self.name!r}>"
+
+
+class SimpleDuckDuckGoSearchTool(Tool):
+    """Lightweight DuckDuckGo web search (HTML scraping, no API key)."""
+
+    name = "web_search"
+    description = "Search the web via DuckDuckGo. Returns the top 5 results."
+    inputs = {"query": {"type": "string", "description": "The search query."}}
+
+    def forward(self, query):
+        BeautifulSoup = _get_bs4()
+        headers = {"User-Agent": "Mozilla/5.0"}
+        try:
+            r = requests.post("https://html.duckduckgo.com/html/",
+                              data={"q": query}, headers=headers, timeout=10)
+            r.raise_for_status()
+            soup = BeautifulSoup(r.text, "html.parser")
+            out = []
+            for res in soup.select(".result")[:5]:
+                title = res.select_one(".result__a")
+                snippet = res.select_one(".result__snippet")
+                if title and snippet:
+                    out.append(
+                        f"- {title.get_text(strip=True)}\n  "
+                        f"{title['href']}\n  {snippet.get_text(strip=True)}"
+                    )
+            return "\n\n".join(out) if out else "No results found."
+        except Exception as e:
+            return f"Search error: {e}"
+
+
+class VisitWebpageTool(Tool):
+    """Fetch a webpage and return its main text content."""
+
+    name = "visit_webpage"
+    description = "Fetch a webpage and return its main text (truncated)."
+    inputs = {"url": {"type": "string", "description": "Full URL to visit"}}
+
+    def __init__(self, max_chars=3000):
+        self.max_chars = max_chars
+
+    def forward(self, url):
+        BeautifulSoup = _get_bs4()
+        headers = {"User-Agent": "Mozilla/5.0"}
+        try:
+            r = requests.get(url, headers=headers, timeout=15)
+            r.raise_for_status()
+            soup = BeautifulSoup(r.text, "html.parser")
+            for tag in soup(["script", "style", "nav", "footer", "header", "aside"]):
+                tag.decompose()
+            text = " ".join(soup.get_text(separator=" ").split())
+            return text[:self.max_chars] or "(empty page)"
+        except Exception as e:
+            return f"Error fetching {url}: {e}"
+
+
+class CalculatorTool(Tool):
+    """Safe arithmetic evaluator."""
+
+    name = "calculator"
+    description = "Evaluate a basic arithmetic expression (numbers, + - * / % ( ) .)."
+    inputs = {
+        "expression": {
+            "type": "string",
+            "description": "Python arithmetic expression like '2 + 2' or '3 * 7'",
+        }
+    }
+
+    def forward(self, expression):
+        allowed = set("0123456789+-*/().% ")
+        if not all(c in allowed for c in expression):
+            return "Error: only numbers and + - * / % ( ) . space allowed"
+        try:
+            return str(eval(expression, {"__builtins__": {}}, {}))
+        except Exception as e:
+            return f"Error: {e}"

lightmodel-0.3.0/src/lightmodel.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: lightmodel
+Version: 0.3.0
+Summary: Ultra-light autonomous AI agents for any OpenAI-compatible API
+Author-email: PlimbAI <plimb.ai.contact@gmail.com>
+License-Expression: MIT
+Keywords: llm,ai,agent,openai,nvidia-nim,tool-calling,no-dependencies
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: search
+Requires-Dist: beautifulsoup4>=4.12; extra == "search"
+Dynamic: license-file
+
+# LightModel
+
+Ultra-light **autonomous AI agents** for any OpenAI-compatible API.
+No `smolagents`, no `litellm`, no `openai` — just `requests`.
+
+## Features
+
+- `LightModel`: HTTP client with automatic retry on transient errors
+- `Agent`: autonomous tool-calling loop with parallel tools and callbacks
+- Built-in tools: `web_search`, `visit_webpage`, `calculator`
+- Extensible: add a tool by subclassing `Tool`
+- Zero heavy dependencies
+
+## Installation
+
+    pip install lightmodel
+    pip install lightmodel[search]   # with beautifulsoup4 for web tools
+
+## Quick start
+
+    from lightmodel import Agent, LightModel, SimpleDuckDuckGoSearchTool
+
+    model = LightModel(
+        model_id="meta/llama-3.3-70b-instruct",
+        api_base="https://integrate.api.nvidia.com/v1",
+        api_key="your_key",
+    )
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        system_prompt="You are a helpful research assistant.",
+        max_steps=6,
+        verbose=True,
+    )
+    print(agent.run("What are the latest AI news in 2026?"))
+
+## Multi-turn conversation
+
+    print(agent.chat("Tell me more about the first result."))
+    print(agent.chat("Summarize in one sentence."))
+
+## Custom tools
+
+    from lightmodel import Tool
+
+    class CalculatorTool(Tool):
+        name = "calculator"
+        description = "Evaluate arithmetic."
+        inputs = {"expression": {"type": "string", "description": "e.g. 2+2"}}
+
+        def forward(self, expression):
+            return str(eval(expression, {"__builtins__": {}}, {}))
+
+## Callbacks
+
+    agent = Agent(
+        model=model,
+        tools=[SimpleDuckDuckGoSearchTool()],
+        callbacks={
+            "on_step": lambda step, msg: print(f"step {step}"),
+            "on_tool_call": lambda name, args: print(f"→ {name}({args})"),
+            "on_tool_result": lambda name, result: print(f"← {result[:80]}"),
+            "on_final": lambda answer: print(f"✓ done"),
+            "on_error": lambda exc: print(f"✗ {exc}"),
+        },
+    )
+
+## Streaming
+
+    for chunk in model.stream_chat([{"role": "user", "content": "Hi"}]):
+        print(chunk, end="", flush=True)
+
+## License
+
+MIT

{lightmodel-0.1.4 → lightmodel-0.3.0}/src/lightmodel.egg-info/SOURCES.txt

@@ -2,6 +2,8 @@ LICENSE
 README.md
 pyproject.toml
 src/lightmodel/__init__.py
+src/lightmodel/agent.py
+src/lightmodel/exceptions.py
 src/lightmodel/model.py
 src/lightmodel/tools.py
 src/lightmodel.egg-info/PKG-INFO

{lightmodel-0.1.4 → lightmodel-0.3.0}/src/lightmodel.egg-info/requires.txt

@@ -2,6 +2,3 @@ requests>=2.28
 
 [search]
 beautifulsoup4>=4.12
-
-[smolagents]
-smolagents>=1.0

lightmodel-0.1.4/PKG-INFO

@@ -1,126 +0,0 @@
-Metadata-Version: 2.4
-Name: lightmodel
-Version: 0.1.4
-Summary: Ultra-light Model adapter and web search tool for smolagents - works with any OpenAI-compatible API
-Author-email: PlimbAi <plimb.ai.contact@gmail.com>
-License: MIT
-Keywords: smolagents,llm,ai,agent,openai,nvidia-nim,duckduckgo,web-search
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.28
-Provides-Extra: smolagents
-Requires-Dist: smolagents>=1.0; extra == "smolagents"
-Provides-Extra: search
-Requires-Dist: beautifulsoup4>=4.12; extra == "search"
-Dynamic: license-file
-
-# LightModel
-
-Ultra-light **Model adapter** and **web search tool** for [smolagents](https://github.com/huggingface/smolagents).
-
-Works with **any** OpenAI-compatible API: NVIDIA NIM, Ollama, vLLM, LM Studio,
-Groq, OpenRouter, Together, DeepSeek, or any custom URL. No heavy dependencies,
-no Rust compilation, runs everywhere (including Termux on Android).
-
-## Features
-
-- `LightModel`: a drop-in `Model` adapter for smolagents using only `requests`.
-- `SimpleDuckDuckGoSearchTool`: a lightweight web search tool that scrapes
-  DuckDuckGo HTML and does not require `ddgs`, `primp`, or Rust toolchain.
-- Zero heavy dependencies: only `requests` (and `beautifulsoup4` for search).
-- Works with any endpoint exposing an OpenAI-compatible `/chat/completions` API.
-
-## Installation
-
-    pip install lightmodel
-    pip install lightmodel[smolagents]   # with smolagents
-    pip install lightmodel[search]       # with beautifulsoup4 for web search
-
-On Termux or restricted environments, install `smolagents` without its heavy
-dependencies:
-
-    export HF_HUB_DISABLE_XET=1
-    pip install --no-deps smolagents
-    pip install --no-deps "huggingface-hub==0.31.2"
-    pip install rich jinja2 pillow python-dotenv requests beautifulsoup4
-    pip install lightmodel
-
-## Usage
-
-### Model only
-
-    from smolagents import CodeAgent
-    from lightmodel import LightModel
-
-    model = LightModel(
-        model_id="meta/llama3-70b-instruct",
-        api_base="https://integrate.api.nvidia.com/v1",
-        api_key="your_nvidia_key",
-    )
-    agent = CodeAgent(tools=[], model=model)
-    agent.run("Explain quantum entanglement in one sentence.")
-
-### Model + web search
-
-    from smolagents import CodeAgent
-    from lightmodel import LightModel, SimpleDuckDuckGoSearchTool
-
-    model = LightModel(
-        model_id="meta/llama3-70b-instruct",
-        api_base="https://integrate.api.nvidia.com/v1",
-        api_key="your_nvidia_key",
-    )
-    agent = CodeAgent(
-        tools=[SimpleDuckDuckGoSearchTool()],
-        model=model,
-    )
-    agent.run("What are the latest AI news in 2026?")
-
-### With Ollama (local)
-
-    model = LightModel(
-        model_id="llama3",
-        api_base="http://localhost:11434/v1",
-    )
-
-### With any custom URL
-
-    model = LightModel(
-        model_id="my-model",
-        api_base="https://my-server.example.com/v1",
-        api_key="my-key",
-    )
-
-## API reference
-
-### `LightModel`
-
-    LightModel(
-        model_id: str,
-        api_base: str,
-        api_key: str = "not-needed",
-        temperature: float = 0.7,
-        max_tokens: int = 2048,
-        timeout: int = 120,
-        extra: dict | None = None,
-    )
-
-- `model_id`: model name sent to the API.
-- `api_base`: base URL. `/chat/completions` is appended automatically.
-- `api_key`: bearer token (optional for local servers).
-- `extra`: extra JSON fields merged into the request payload.
-
-### `SimpleDuckDuckGoSearchTool`
-
-    SimpleDuckDuckGoSearchTool()
-
-Scrapes DuckDuckGo HTML results and returns the top 5 as formatted text.
-No API key required. No Rust dependency.
-
-## License
-
-MIT

lightmodel-0.1.4/README.md

@@ -1,106 +0,0 @@
-# LightModel
-
-Ultra-light **Model adapter** and **web search tool** for [smolagents](https://github.com/huggingface/smolagents).
-
-Works with **any** OpenAI-compatible API: NVIDIA NIM, Ollama, vLLM, LM Studio,
-Groq, OpenRouter, Together, DeepSeek, or any custom URL. No heavy dependencies,
-no Rust compilation, runs everywhere (including Termux on Android).
-
-## Features
-
-- `LightModel`: a drop-in `Model` adapter for smolagents using only `requests`.
-- `SimpleDuckDuckGoSearchTool`: a lightweight web search tool that scrapes
-  DuckDuckGo HTML and does not require `ddgs`, `primp`, or Rust toolchain.
-- Zero heavy dependencies: only `requests` (and `beautifulsoup4` for search).
-- Works with any endpoint exposing an OpenAI-compatible `/chat/completions` API.
-
-## Installation
-
-    pip install lightmodel
-    pip install lightmodel[smolagents]   # with smolagents
-    pip install lightmodel[search]       # with beautifulsoup4 for web search
-
-On Termux or restricted environments, install `smolagents` without its heavy
-dependencies:
-
-    export HF_HUB_DISABLE_XET=1
-    pip install --no-deps smolagents
-    pip install --no-deps "huggingface-hub==0.31.2"
-    pip install rich jinja2 pillow python-dotenv requests beautifulsoup4
-    pip install lightmodel
-
-## Usage
-
-### Model only
-
-    from smolagents import CodeAgent
-    from lightmodel import LightModel
-
-    model = LightModel(
-        model_id="meta/llama3-70b-instruct",
-        api_base="https://integrate.api.nvidia.com/v1",
-        api_key="your_nvidia_key",
-    )
-    agent = CodeAgent(tools=[], model=model)
-    agent.run("Explain quantum entanglement in one sentence.")
-
-### Model + web search
-
-    from smolagents import CodeAgent
-    from lightmodel import LightModel, SimpleDuckDuckGoSearchTool
-
-    model = LightModel(
-        model_id="meta/llama3-70b-instruct",
-        api_base="https://integrate.api.nvidia.com/v1",
-        api_key="your_nvidia_key",
-    )
-    agent = CodeAgent(
-        tools=[SimpleDuckDuckGoSearchTool()],
-        model=model,
-    )
-    agent.run("What are the latest AI news in 2026?")
-
-### With Ollama (local)
-
-    model = LightModel(
-        model_id="llama3",
-        api_base="http://localhost:11434/v1",
-    )
-
-### With any custom URL
-
-    model = LightModel(
-        model_id="my-model",
-        api_base="https://my-server.example.com/v1",
-        api_key="my-key",
-    )
-
-## API reference
-
-### `LightModel`
-
-    LightModel(
-        model_id: str,
-        api_base: str,
-        api_key: str = "not-needed",
-        temperature: float = 0.7,
-        max_tokens: int = 2048,
-        timeout: int = 120,
-        extra: dict | None = None,
-    )
-
-- `model_id`: model name sent to the API.
-- `api_base`: base URL. `/chat/completions` is appended automatically.
-- `api_key`: bearer token (optional for local servers).
-- `extra`: extra JSON fields merged into the request payload.
-
-### `SimpleDuckDuckGoSearchTool`
-
-    SimpleDuckDuckGoSearchTool()
-
-Scrapes DuckDuckGo HTML results and returns the top 5 as formatted text.
-No API key required. No Rust dependency.
-
-## License
-
-MIT

lightmodel-0.1.4/src/lightmodel/__init__.py

@@ -1,6 +0,0 @@
-"""LightModel - Ultra-light Model adapter and web search tool for smolagents."""
-from .model import LightModel
-from .tools import SimpleDuckDuckGoSearchTool
-
-__version__ = "0.1.0"
-__all__ = ["LightModel", "SimpleDuckDuckGoSearchTool"]

lightmodel-0.1.4/src/lightmodel/model.py

@@ -1,126 +0,0 @@
-"""LightModel - lightweight Model adapter for smolagents."""
-import json
-import requests
-
-from smolagents import Model
-
-try:
-    from smolagents.models import ChatMessage, MessageRole
-    ROLE_ASSISTANT = MessageRole.ASSISTANT
-except ImportError:
-    from smolagents.models import ChatMessage
-    ROLE_ASSISTANT = "assistant"
-
-
-class LightModel(Model):
-    """Universal adapter for any OpenAI-compatible API with tool calling."""
-
-    def __init__(self, model_id, api_base, api_key="not-needed",
-                 temperature=0.7, max_tokens=2048, timeout=120, extra=None):
-        super().__init__()
-        self.model_id = model_id
-        base = api_base.rstrip("/")
-        if not base.endswith("/chat/completions"):
-            base += "/chat/completions"
-        self.api_url = base
-        self.api_key = api_key
-        self.temperature = temperature
-        self.max_tokens = max_tokens
-        self.timeout = timeout
-        self.extra = extra or {}
-
-    def generate(self, messages, stop_sequences=None, response_format=None,
-                 tools_to_call_from=None, **kwargs):
-        headers = {"Content-Type": "application/json"}
-        if self.api_key:
-            headers["Authorization"] = f"Bearer {self.api_key}"
-
-        payload = {
-            "model": self.model_id,
-            "messages": self._to_openai(messages),
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens,
-            **self.extra,
-        }
-        if tools_to_call_from:
-            payload["tools"] = self._tools_to_openai(tools_to_call_from)
-            payload["tool_choice"] = "auto"
-        if stop_sequences:
-            payload["stop"] = stop_sequences
-
-        r = requests.post(self.api_url, json=payload, headers=headers,
-                          timeout=self.timeout)
-        if r.status_code >= 400:
-            raise RuntimeError(f"API {r.status_code}: {r.text[:300]}")
-
-        try:
-            msg = r.json()["choices"][0]["message"]
-        except (KeyError, IndexError):
-            raise RuntimeError(f"Invalid response: {r.text[:300]}")
-
-        content = msg.get("content") or ""
-        raw_calls = msg.get("tool_calls") or []
-        chat_msg = ChatMessage(role=ROLE_ASSISTANT, content=content)
-        if raw_calls:
-            chat_msg.tool_calls = [
-                {
-                    "id": tc.get("id", f"call_{i}"),
-                    "type": "function",
-                    "function": {
-                        "name": tc["function"]["name"],
-                        "arguments": tc["function"]["arguments"],
-                    },
-                }
-                for i, tc in enumerate(raw_calls)
-            ]
-        return chat_msg
-
-    @staticmethod
-    def _tools_to_openai(tools):
-        out = []
-        for t in tools:
-            props, required = {}, []
-            for name, spec in (t.inputs or {}).items():
-                props[name] = {
-                    "type": spec.get("type", "string"),
-                    "description": spec.get("description", ""),
-                }
-                required.append(name)
-            out.append({
-                "type": "function",
-                "function": {
-                    "name": t.name,
-                    "description": t.description,
-                    "parameters": {
-                        "type": "object",
-                        "properties": props,
-                        "required": required,
-                    },
-                },
-            })
-        return out
-
-    @staticmethod
-    def _to_openai(messages):
-        ROLE_MAP = {"tool-call": "assistant"}
-        out = []
-        for m in messages:
-            if isinstance(m, dict):
-                role, content = m.get("role", "user"), m.get("content", "")
-                tool_call_id = m.get("tool_call_id")
-            else:
-                role = getattr(m, "role", "user")
-                content = getattr(m, "content", "") or ""
-                tool_call_id = getattr(m, "tool_call_id", None)
-            if hasattr(role, "value"):
-                role = role.value
-            role = str(role)
-            if role in ("tool-response", "tool"):
-                msg = {"role": "tool", "content": str(content)}
-                if tool_call_id:
-                    msg["tool_call_id"] = tool_call_id
-                out.append(msg)
-                continue
-            role = ROLE_MAP.get(role, role)
-            out.append({"role": role, "content": str(content)})
-        return out

lightmodel-0.1.4/src/lightmodel/tools.py

@@ -1,39 +0,0 @@
-"""Lightweight tools for smolagents."""
-import requests
-from bs4 import BeautifulSoup
-from smolagents import Tool
-
-
-class SimpleDuckDuckGoSearchTool(Tool):
-    """Lightweight DuckDuckGo web search tool (HTML scraping, no Rust)."""
-
-    name = "web_search"
-    description = "Search the web for information via DuckDuckGo."
-    inputs = {
-        "query": {
-            "type": "string",
-            "description": "The search query.",
-        }
-    }
-    output_type = "string"
-
-    def forward(self, query: str) -> str:
-        url = "https://html.duckduckgo.com/html/"
-        headers = {"User-Agent": "Mozilla/5.0"}
-        params = {"q": query}
-        try:
-            response = requests.post(url, data=params, headers=headers, timeout=10)
-            response.raise_for_status()
-            soup = BeautifulSoup(response.text, "html.parser")
-            results = []
-            for result in soup.select(".result")[:5]:
-                title_tag = result.select_one(".result__a")
-                snippet_tag = result.select_one(".result__snippet")
-                if title_tag and snippet_tag:
-                    title = title_tag.get_text(strip=True)
-                    link = title_tag["href"]
-                    snippet = snippet_tag.get_text(strip=True)
-                    results.append(f"- {title}\n  {link}\n  {snippet}")
-            return "\n\n".join(results) if results else "No results found."
-        except Exception as e:
-            return f"Search error: {e}"

lightmodel-0.1.4/src/lightmodel.egg-info/PKG-INFO

@@ -1,126 +0,0 @@
-Metadata-Version: 2.4
-Name: lightmodel
-Version: 0.1.4
-Summary: Ultra-light Model adapter and web search tool for smolagents - works with any OpenAI-compatible API
-Author-email: PlimbAi <plimb.ai.contact@gmail.com>
-License: MIT
-Keywords: smolagents,llm,ai,agent,openai,nvidia-nim,duckduckgo,web-search
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.28
-Provides-Extra: smolagents
-Requires-Dist: smolagents>=1.0; extra == "smolagents"
-Provides-Extra: search
-Requires-Dist: beautifulsoup4>=4.12; extra == "search"
-Dynamic: license-file
-
-# LightModel
-
-Ultra-light **Model adapter** and **web search tool** for [smolagents](https://github.com/huggingface/smolagents).
-
-Works with **any** OpenAI-compatible API: NVIDIA NIM, Ollama, vLLM, LM Studio,
-Groq, OpenRouter, Together, DeepSeek, or any custom URL. No heavy dependencies,
-no Rust compilation, runs everywhere (including Termux on Android).
-
-## Features
-
-- `LightModel`: a drop-in `Model` adapter for smolagents using only `requests`.
-- `SimpleDuckDuckGoSearchTool`: a lightweight web search tool that scrapes
-  DuckDuckGo HTML and does not require `ddgs`, `primp`, or Rust toolchain.
-- Zero heavy dependencies: only `requests` (and `beautifulsoup4` for search).
-- Works with any endpoint exposing an OpenAI-compatible `/chat/completions` API.
-
-## Installation
-
-    pip install lightmodel
-    pip install lightmodel[smolagents]   # with smolagents
-    pip install lightmodel[search]       # with beautifulsoup4 for web search
-
-On Termux or restricted environments, install `smolagents` without its heavy
-dependencies:
-
-    export HF_HUB_DISABLE_XET=1
-    pip install --no-deps smolagents
-    pip install --no-deps "huggingface-hub==0.31.2"
-    pip install rich jinja2 pillow python-dotenv requests beautifulsoup4
-    pip install lightmodel
-
-## Usage
-
-### Model only
-
-    from smolagents import CodeAgent
-    from lightmodel import LightModel
-
-    model = LightModel(
-        model_id="meta/llama3-70b-instruct",
-        api_base="https://integrate.api.nvidia.com/v1",
-        api_key="your_nvidia_key",
-    )
-    agent = CodeAgent(tools=[], model=model)
-    agent.run("Explain quantum entanglement in one sentence.")
-
-### Model + web search
-
-    from smolagents import CodeAgent
-    from lightmodel import LightModel, SimpleDuckDuckGoSearchTool
-
-    model = LightModel(
-        model_id="meta/llama3-70b-instruct",
-        api_base="https://integrate.api.nvidia.com/v1",
-        api_key="your_nvidia_key",
-    )
-    agent = CodeAgent(
-        tools=[SimpleDuckDuckGoSearchTool()],
-        model=model,
-    )
-    agent.run("What are the latest AI news in 2026?")
-
-### With Ollama (local)
-
-    model = LightModel(
-        model_id="llama3",
-        api_base="http://localhost:11434/v1",
-    )
-
-### With any custom URL
-
-    model = LightModel(
-        model_id="my-model",
-        api_base="https://my-server.example.com/v1",
-        api_key="my-key",
-    )
-
-## API reference
-
-### `LightModel`
-
-    LightModel(
-        model_id: str,
-        api_base: str,
-        api_key: str = "not-needed",
-        temperature: float = 0.7,
-        max_tokens: int = 2048,
-        timeout: int = 120,
-        extra: dict | None = None,
-    )
-
-- `model_id`: model name sent to the API.
-- `api_base`: base URL. `/chat/completions` is appended automatically.
-- `api_key`: bearer token (optional for local servers).
-- `extra`: extra JSON fields merged into the request payload.
-
-### `SimpleDuckDuckGoSearchTool`
-
-    SimpleDuckDuckGoSearchTool()
-
-Scrapes DuckDuckGo HTML results and returns the top 5 as formatted text.
-No API key required. No Rust dependency.
-
-## License
-
-MIT