smart-artificial-intelligence-local 0.0b7__tar.gz

smart_artificial_intelligence_local-0.0b7/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: smart-artificial-intelligence-local
+Version: 0.0b7
+Summary: PyPI smart-artificial-intelligence-local Python Package owned by Circlez.ai
+Home-page: https://github.com/circles-zone/smart-artificial-intelligence-local-python-package
+Author: Circles
+Author-email: info@circlez.ai
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: python-sdk-remote
+Requires-Dist: logger-local
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+PyPI smart-artificial-intelligence-local Python Package owned by Circlez.ai

smart_artificial_intelligence_local-0.0b7/README.md

@@ -0,0 +1,25 @@
+# General
+
+Unlike the README.md in the root directory, this is a README.md of this specific repo/package<br>
+
+TODO Please update this README.md of this specific repo/package and not the README.md in the root directory based on the python-package-template repo<br>
+
+## TODOs
+
+TODO Like smart-datastore package smark-ai should allow to run prompt with multiple LLMs using ai repo instances.<br>
+TODO use API-management to perform API-type, so if an API failed we try other APIs from the same API type. 
+TODO use cost allocation tags or equivant to measure the costs. 
+
+## Versions
+
+[pub] 0.0.1 Initial version (change the directories, files, setup.py, .github/workflows/*.yml)<br>
+
+## Installing instructions
+
+It's advised to use venv<br>
+If you have Windows, it's also advised to use Windows Subsystem for Linux<br>
+
+## Install dependencies
+
+Run ./download-beta-sdk.sh from the bash terminal<br>
+Run pip install -r requirements.txt from the bash terminal<br>

smart_artificial_intelligence_local-0.0b7/pyproject.toml

@@ -0,0 +1,29 @@
+# This file should be in the future instead of setup.py
+# https://python-poetry.org/docs/pyproject
+# https://stackoverflow.com/questions/78048223/adding-folder-with-data-with-pyproject-toml
+# https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#license
+
+# This file is mandatory for the `poetry version patch`
+
+# It seems we need to copy this file also to serverless-com repo, as required by dialog-workflow-python-package
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+
+[tool.poetry]
+name = "smart-artificial-intelligence-local"
+# I believe we are still using the version from setup.py and not from here until Potery will work
+version = "0.0.3" # https://pypi.org/project/smart-artificial-intelligence-local/
+description = "smart-artificial-intelligence-local Python Package"
+readme = "README.md"
+authors = [
+    "Circlez.ai <info@circlez.ai>",
+]
+
+[tool.poetry.dev-dependencies]
+pytest = "^8.0"
+pytest-cov = "^5.0"

smart_artificial_intelligence_local-0.0b7/setup.cfg

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

smart_artificial_intelligence_local-0.0b7/setup.py

@@ -0,0 +1,30 @@
+import setuptools
+
+PACKAGE_NAME = "smart-artificial-intelligence-local"
+
+package_dir = PACKAGE_NAME.replace("-", "_")
+
+PACKAGE_DESCRIPTION = f"PyPI {PACKAGE_NAME} Python Package owned by Circlez.ai"
+
+setuptools.setup(
+    name=PACKAGE_NAME,
+    version="0.0b7",  # https://pypi.org/project/smart-artificial-intelligence-local/
+    author="Circles",
+    author_email="info@circlez.ai",
+    description=PACKAGE_DESCRIPTION,
+    long_description=PACKAGE_DESCRIPTION,
+    long_description_content_type='text/markdown',
+    url=f"https://github.com/circles-zone/{PACKAGE_NAME}-python-package",
+    packages=setuptools.find_packages(),
+    package_data={package_dir: ['*.py']},
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    # The Smart-LLM reconciler is transport-agnostic: models/judge/reaction-sink are injected
+    # callables, so strands/ollama are NOT runtime deps (the orchestrator supplies real models).
+    install_requires=[
+        'python-sdk-remote',
+        'logger-local',
+    ]
+)

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local/src/__init__.py

@@ -0,0 +1,3 @@
+from .smart_artificial_intelligence_local import SmartArtificialIntelligenceLocal
+
+__all__ = ["SmartArtificialIntelligenceLocal"]

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local/src/constants.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+from logger_local.LoggerComponentEnum import LoggerComponentEnum
+
+
+class ConstantsSrcSmartArtificialIntelligenceLocal:
+    """This is a class of all the constants of SmartArtificialIntelligenceLocal"""
+
+    DEVELOPER_EMAIL_ADDRESS: str = 'tal.r@circ.zone'
+
+    SMART_ARTIFICIAL_INTELLIGENCE_LOCAL_PYTHON_CODE_COMPONENT_ID: int = 10105
+
+    SMART_ARTIFICIAL_INTELLIGENCE_LOCAL_PYTHON_COMPONENT_NAME = 'Smart Artificial Intelligence local Python package'
+    # TODO SMART_ARTIFICIAL_INTELLIGENCE_LOCAL_PYTHON_CODE_LOGGER_INIT-OBJECT
+    SMART_ARTIFICIAL_INTELLIGENCE_LOCAL_PYTHON_CODE_LOGGER_OBJECT: dict[str, Any] = {
+        'component_id': SMART_ARTIFICIAL_INTELLIGENCE_LOCAL_PYTHON_CODE_COMPONENT_ID,
+        'component_name': SMART_ARTIFICIAL_INTELLIGENCE_LOCAL_PYTHON_COMPONENT_NAME,
+        'component_category': LoggerComponentEnum.ComponentCategory.Code.value,
+        'developer_email_address': DEVELOPER_EMAIL_ADDRESS
+    }
+
+    # Smart-LLM orchestration modes (page-2 design).
+    MODE_JUDGE: str = 'judge'        # Mode 1: run N models, an LLM-as-judge picks the best answer
+    MODE_REACTION: str = 'reaction'  # Mode 2: run N models, keep all answers + log to reaction store
+    MODE_CASCADE: str = 'cascade'    # Efficient: cheapest model first; escalate only when unsure
+
+    # Cascade: escalate to the next model only if the current one's confidence is below this.
+    DEFAULT_ESCALATE_CONFIDENCE: float = 0.75

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local/src/smart_artificial_intelligence_local.py

@@ -0,0 +1,167 @@
+"""Smart-LLM: run a prompt across several models and reconcile -- efficiently.
+
+Three modes (page-2 "Analyzer LLM Serving" design):
+
+* Mode CASCADE (efficient default): call the CHEAPEST model first; if it is confident, stop -- one
+                      call. Only when it is unsure do we escalate to the next (different, stronger)
+                      model; and only when the two DISAGREE do we invoke the judge. Easy lines cost
+                      one call; the panel + judge fire just for the hard ones.
+* Mode JUDGE:    query every model, then an LLM-as-judge picks the best answer set (majority-vote
+                      fallback when no judge is supplied).
+* Mode REACTION: query every model, keep every answer, log each to a reaction store (injected sink)
+                      with a flag for the selected one -- signal to improve later.
+
+Everything is injected -- a "model" is any ``callable(prompt) -> answer`` where ``answer`` is either a
+``list[str]`` (names) or a ``(list[str], confidence_float)`` tuple (cascade needs the confidence). The
+judge is ``callable(prompt, [(model_name, answer)]) -> list[str]`` and the reaction sink is
+``callable(model_name, prompt, answer, is_selected)``. So this package has no hard dependency on a
+running model / a database: the orchestrator wires real ones, tests wire fakes.
+
+After each ``smart_identify`` the ``last_trace`` attribute holds a decision trace (calls made, whether
+it escalated / agreed / used the judge) so the caller can meter cost.
+"""
+from __future__ import annotations
+
+import math
+from typing import Callable, List, Optional, Sequence, Tuple
+
+from logger_local.MetaLogger import MetaLogger
+
+from .constants import ConstantsSrcSmartArtificialIntelligenceLocal as Consts
+
+Model = Callable[[str], Sequence]
+Judge = Callable[[str, List[Tuple[str, List[str]]]], Sequence[str]]
+ReactionSink = Callable[[str, str, List[str], bool], None]
+
+
+def _normalize(answer) -> Tuple[List[str], float]:
+    """Coerce a model's return into (names, confidence). A bare list -> confidence 1.0."""
+    if (isinstance(answer, tuple) and len(answer) == 2
+            and isinstance(answer[1], (int, float)) and not isinstance(answer[1], bool)
+            and isinstance(answer[0], (list, tuple))):
+        return [str(name) for name in answer[0]], float(answer[1])
+    return [str(name) for name in answer], 1.0
+
+
+class SmartArtificialIntelligenceLocal(  # type: ignore[call-arg]  # MetaLogger takes object=
+        metaclass=MetaLogger,
+        object=Consts.SMART_ARTIFICIAL_INTELLIGENCE_LOCAL_PYTHON_CODE_LOGGER_OBJECT):
+    """Reconcile several models' answers for one prompt (cascade / judge / reaction)."""
+
+    def __init__(self, models: Optional[Sequence[Model]] = None, judge: Optional[Judge] = None,
+                 reaction_sink: Optional[ReactionSink] = None,
+                 escalate_confidence: float = Consts.DEFAULT_ESCALATE_CONFIDENCE,
+                 is_test_data: bool = False) -> None:
+        self._models = list(models or [])
+        self._judge = judge
+        self._reaction_sink = reaction_sink
+        self.escalate_confidence = escalate_confidence
+        self.is_test_data = is_test_data
+        self.last_trace: dict = {}
+
+    def smart_identify(self, prompt: str, *, mode: str = Consts.MODE_JUDGE) -> List[str]:
+        """Return the reconciled answer (list of names) for `prompt` across the models."""
+        if not self._models:
+            self.last_trace = {"calls": 0}
+            return []
+        if mode == Consts.MODE_CASCADE:
+            return self._cascade(prompt)
+        return self._panel(prompt, mode)
+
+    # ---------------------------------------------------------------- cascade (efficient) --
+    def _cascade(self, prompt: str) -> List[str]:
+        names0, confidence0, name0, ok0 = self._invoke(0, prompt)
+        trace: dict = {"calls": 1 if ok0 else 0, "escalated": False, "agreed": None,
+                       "judged": False, "answered_by": name0}
+
+        # Tier-1 confident enough (or no second tier) -> stop at one call.
+        if ok0 and (confidence0 >= self.escalate_confidence or len(self._models) < 2):
+            self.last_trace = trace
+            return names0
+
+        if len(self._models) < 2:
+            self.last_trace = trace
+            return names0 if ok0 else []
+
+        # Escalate to a different, stronger model.
+        names1, _confidence1, name1, ok1 = self._invoke(1, prompt)
+        trace["escalated"] = True
+        trace["calls"] += 1 if ok1 else 0
+        if not ok1:
+            self.last_trace = trace
+            return names0 if ok0 else []
+        if not ok0:
+            self.last_trace = trace
+            return names1
+
+        # Agree -> done (judge skipped). Disagree -> judge / reaction resolves it.
+        if set(names0) == set(names1):
+            trace["agreed"] = True
+            self.last_trace = trace
+            return names1
+
+        trace["agreed"] = False
+        answers = [(name0, names0), (name1, names1)]
+        if self._judge is not None:
+            selected = list(self._judge(prompt, answers))
+            trace["judged"] = True
+            trace["calls"] += 1
+        else:
+            selected = self._majority_vote(answers)
+        if self._reaction_sink is not None:
+            for model_name, answer in answers:
+                self._reaction_sink(model_name, prompt, answer, set(answer) == set(selected))
+        self.last_trace = trace
+        return selected
+
+    # ------------------------------------------------------------- panel (judge / reaction) --
+    def _panel(self, prompt: str, mode: str) -> List[str]:
+        answers: List[Tuple[str, List[str]]] = []
+        for index in range(len(self._models)):
+            names, _confidence, model_name, ok = self._invoke(index, prompt)
+            if ok:
+                answers.append((model_name, names))
+        if not answers:
+            self.last_trace = {"calls": 0}
+            return []
+
+        if mode == Consts.MODE_JUDGE and self._judge is not None:
+            selected = list(self._judge(prompt, answers))
+            judged = True
+        else:
+            selected = self._majority_vote(answers)
+            judged = False
+
+        if mode == Consts.MODE_REACTION and self._reaction_sink is not None:
+            for model_name, answer in answers:
+                self._reaction_sink(model_name, prompt, answer, set(answer) == set(selected))
+
+        self.last_trace = {"calls": len(answers) + (1 if judged else 0),
+                           "escalated": True, "judged": judged}
+        return selected
+
+    # --------------------------------------------------------------------------- helpers --
+    def _invoke(self, index: int, prompt: str) -> Tuple[List[str], float, str, bool]:
+        """Call model `index`; return (names, confidence, name, ok). ok=False if it raised."""
+        model = self._models[index]
+        model_name = getattr(model, "name", f"model_{index}")
+        try:
+            names, confidence = _normalize(model(prompt))
+            return names, confidence, model_name, True
+        except Exception as exception:  # noqa: BLE001 -- one bad model must not sink the call
+            self.logger.warning(f"model '{model_name}' failed: {exception}")  # type: ignore[attr-defined]
+            return [], 0.0, model_name, False
+
+    @staticmethod
+    def _majority_vote(answers: List[Tuple[str, List[str]]]) -> List[str]:
+        """Keep every item that at least half of the models returned (union fallback for ties)."""
+        threshold = math.ceil(len(answers) / 2)
+        counts: dict = {}
+        order: List[str] = []
+        for _model_name, answer in answers:
+            for item in dict.fromkeys(answer):  # de-dup within a model
+                if item not in counts:
+                    order.append(item)
+                counts[item] = counts.get(item, 0) + 1
+        voted = [item for item in order if counts[item] >= threshold]
+        return voted or order  # if nothing reaches the threshold, return the union

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local/tests/smart_artificial_intelligence_local_test.py

@@ -0,0 +1,128 @@
+"""Tests for the Smart-LLM multi-model reconciler (judge + reaction), no models/DB required."""
+from smart_artificial_intelligence_local.src.constants import (
+    ConstantsSrcSmartArtificialIntelligenceLocal as Consts,
+)
+from smart_artificial_intelligence_local.src.smart_artificial_intelligence_local import (
+    SmartArtificialIntelligenceLocal,
+)
+
+
+def _model(name, answer):
+    fn = lambda prompt: list(answer)  # noqa: E731 -- tiny fake model
+    fn.name = name
+    return fn
+
+
+def _cmodel(name, answer, confidence):
+    """A fake model returning (names, confidence) -- the cascade form."""
+    fn = lambda prompt: (list(answer), confidence)  # noqa: E731
+    fn.name = name
+    return fn
+
+
+def _counting(name, answer, confidence):
+    """Like _cmodel but records how many times it was called (to prove no wasted calls)."""
+    calls = {"n": 0}
+
+    def fn(prompt):
+        calls["n"] += 1
+        return list(answer), confidence
+    fn.name = name
+    fn.calls = calls
+    return fn
+
+
+def test_judge_mode_uses_the_judge_choice():
+    models = [_model("a", ["Dave", "Berlin"]), _model("b", ["Dave"])]
+    judge = lambda prompt, answers: ["Dave"]  # noqa: E731
+    smart = SmartArtificialIntelligenceLocal(models=models, judge=judge, is_test_data=True)
+    assert smart.smart_identify("p", mode=Consts.MODE_JUDGE) == ["Dave"]
+
+
+def test_judge_mode_without_judge_falls_back_to_majority_vote():
+    # "Dave" in 2/3 models (kept), "Berlin" in 1/3 (dropped)
+    models = [_model("a", ["Dave", "Berlin"]), _model("b", ["Dave"]), _model("c", ["Dave"])]
+    smart = SmartArtificialIntelligenceLocal(models=models, is_test_data=True)
+    assert smart.smart_identify("p") == ["Dave"]
+
+
+def test_reaction_mode_logs_every_answer_with_selection_flag():
+    logged = []
+    sink = lambda model, prompt, answer, selected: logged.append((model, tuple(answer), selected))  # noqa: E731
+    models = [_model("a", ["Dave"]), _model("b", ["Dave"]), _model("b2", ["Nadia"])]
+    smart = SmartArtificialIntelligenceLocal(models=models, reaction_sink=sink, is_test_data=True)
+
+    result = smart.smart_identify("p", mode=Consts.MODE_REACTION)
+    assert result == ["Dave"]                       # majority (2/3)
+    assert len(logged) == 3                          # one reaction row per model
+    assert ("a", ("Dave",), True) in logged          # the selected answer is flagged
+    assert ("b2", ("Nadia",), False) in logged       # a losing answer is flagged False
+
+
+def test_a_failing_model_is_skipped_not_fatal():
+    def boom(prompt):
+        raise RuntimeError("model down")
+    models = [boom, _model("ok", ["Dave"])]
+    smart = SmartArtificialIntelligenceLocal(models=models, is_test_data=True)
+    assert smart.smart_identify("p") == ["Dave"]
+
+
+def test_no_models_returns_empty():
+    assert SmartArtificialIntelligenceLocal(models=[], is_test_data=True).smart_identify("p") == []
+
+
+# --------------------------------------------------------------------- cascade (efficiency) --
+def test_cascade_stops_at_tier1_when_confident():
+    tier2 = _counting("cloud", ["Nadia"], 0.9)
+    models = [_cmodel("local", ["Dave"], 0.95), tier2]
+    smart = SmartArtificialIntelligenceLocal(models=models, escalate_confidence=0.75,
+                                             is_test_data=True)
+    result = smart.smart_identify("p", mode=Consts.MODE_CASCADE)
+    assert result == ["Dave"]
+    assert tier2.calls["n"] == 0                 # never escalated -> no second call
+    assert smart.last_trace["calls"] == 1
+    assert smart.last_trace["escalated"] is False
+
+
+def test_cascade_escalates_when_unsure_and_agreement_skips_judge():
+    judge_calls = {"n": 0}
+
+    def judge(prompt, answers):
+        judge_calls["n"] += 1
+        return ["Dave"]
+    models = [_cmodel("local", ["Dave"], 0.40), _cmodel("cloud", ["Dave"], 0.90)]
+    smart = SmartArtificialIntelligenceLocal(models=models, judge=judge,
+                                             escalate_confidence=0.75, is_test_data=True)
+    result = smart.smart_identify("p", mode=Consts.MODE_CASCADE)
+    assert result == ["Dave"]
+    assert judge_calls["n"] == 0                  # models agreed -> judge NOT invoked
+    assert smart.last_trace["escalated"] is True
+    assert smart.last_trace["agreed"] is True
+    assert smart.last_trace["calls"] == 2
+
+
+def test_cascade_invokes_judge_on_disagreement():
+    judge_calls = {"n": 0}
+
+    def judge(prompt, answers):
+        judge_calls["n"] += 1
+        return ["Nadia"]
+    models = [_cmodel("local", ["Dave"], 0.40), _cmodel("cloud", ["Nadia"], 0.90)]
+    smart = SmartArtificialIntelligenceLocal(models=models, judge=judge,
+                                             escalate_confidence=0.75, is_test_data=True)
+    result = smart.smart_identify("p", mode=Consts.MODE_CASCADE)
+    assert result == ["Nadia"]
+    assert judge_calls["n"] == 1                  # disagreement -> judge decides
+    assert smart.last_trace["judged"] is True
+    assert smart.last_trace["calls"] == 3
+
+
+def test_cascade_logs_reaction_on_disagreement_without_judge():
+    logged = []
+    sink = lambda m, p, a, s: logged.append((m, tuple(a), s))  # noqa: E731
+    models = [_cmodel("local", ["Dave"], 0.40), _cmodel("cloud", ["Nadia"], 0.90)]
+    smart = SmartArtificialIntelligenceLocal(models=models, reaction_sink=sink,
+                                             escalate_confidence=0.75, is_test_data=True)
+    smart.smart_identify("p", mode=Consts.MODE_CASCADE)
+    assert len(logged) == 2                       # both tiers logged on disagreement
+    assert smart.last_trace["judged"] is False

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: smart-artificial-intelligence-local
+Version: 0.0b7
+Summary: PyPI smart-artificial-intelligence-local Python Package owned by Circlez.ai
+Home-page: https://github.com/circles-zone/smart-artificial-intelligence-local-python-package
+Author: Circles
+Author-email: info@circlez.ai
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: python-sdk-remote
+Requires-Dist: logger-local
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+PyPI smart-artificial-intelligence-local Python Package owned by Circlez.ai

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+setup.py
+smart_artificial_intelligence_local/__init__.py
+smart_artificial_intelligence_local.egg-info/PKG-INFO
+smart_artificial_intelligence_local.egg-info/SOURCES.txt
+smart_artificial_intelligence_local.egg-info/dependency_links.txt
+smart_artificial_intelligence_local.egg-info/requires.txt
+smart_artificial_intelligence_local.egg-info/top_level.txt
+smart_artificial_intelligence_local/src/__init__.py
+smart_artificial_intelligence_local/src/constants.py
+smart_artificial_intelligence_local/src/smart_artificial_intelligence_local.py
+smart_artificial_intelligence_local/tests/__init__.py
+smart_artificial_intelligence_local/tests/smart_artificial_intelligence_local_test.py

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local.egg-info/requires.txt

@@ -0,0 +1,2 @@
+python-sdk-remote
+logger-local

smart_artificial_intelligence_local-0.0b7/smart_artificial_intelligence_local.egg-info/top_level.txt

@@ -0,0 +1 @@
+smart_artificial_intelligence_local