multidimensions 0.1.0__tar.gz

multidimensions-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: multidimensions
+Version: 0.1.0
+Summary: Framework for Reasoning and Agentic base
+Author: Alexander Baum
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai
+Requires-Dist: anthropic
+Dynamic: license-file
+
+Dieses Framework bildet die Grundlage für Multistep-Reasoning und den Bau von Agenten.
+
+Aktuell wurde ein vierstufiges Reasoning eingefügt.
+
+1. Analyse
+2. Planung
+3. Lösung 
+4. Fertige Antwort
+
+Die derzeitigen Prompts für die jeweiligen Schritte sind minimal gestaltet. Der aktuelle Fokus liegt auf dem sicherstellen der Funktionalität sowie dem Implementieren neuer Funktionen. Im späteren Verlauf wird das konkrete Prompting für das LLM ausgearbeitet.
+
+
+Schnittstelle:
+-> Über ProviderConfig werden die Attribute 'base_url', 'api_key', 'model' und 'provider' übergeben. Dabei sind alles Strings, 'provider' ist als Plaintext geschrieben 'openai' / 'anthropic'. Schließlich wird das Providerobjekt instanziert durch das Übergeben des ProviderConfig-Objektes durch Provider.from_config().
+Die Providerinstanz wird als model_engine an das Raesoning übergeben.
+
+
+Diese Funktion muss folgende Variablen + Datentypen empfangen: 
+- user_prompt (str)
+- system_prompt (str)
+
+Der User muss sicherstellen, dass der eigentliche LLM-Aufruf in dieser Funktion erfolgt und das 'return'-Statement der Funktion die Antwort des LLMs als String zurückgibt. 
+
+
+Der unkomplizierteste Weg liegt in der passenden Nutzung des internen 'Provider'-Moduls. Dieses ist ausdrücklich auf die Kompatibilität ausgerichtet und enthält eigene Fehler sowie Infrastruktur über eigene DTOs. Zudem bietet es sehr hohe Abstraktion bei minimalster Eingabe.
+
+--------------------------
+
+Die Reasoner-eigene Funktion namens "think()" erwartet die initiale Nuteranfrage (user_prompt).
+
+Sie ruft aktuell vier mal die Funktion 'generate()' aus dem übergebenen Ojekt auf und liefert am Ende die finale Antwort als String an den Aufrufer.
+Durch das Flag 'print_thinking_steps' (standardmäßig False) werden die "Thinking-Steps" ausgegeben.

multidimensions-0.1.0/README.md

@@ -0,0 +1,32 @@
+Dieses Framework bildet die Grundlage für Multistep-Reasoning und den Bau von Agenten.
+
+Aktuell wurde ein vierstufiges Reasoning eingefügt.
+
+1. Analyse
+2. Planung
+3. Lösung 
+4. Fertige Antwort
+
+Die derzeitigen Prompts für die jeweiligen Schritte sind minimal gestaltet. Der aktuelle Fokus liegt auf dem sicherstellen der Funktionalität sowie dem Implementieren neuer Funktionen. Im späteren Verlauf wird das konkrete Prompting für das LLM ausgearbeitet.
+
+
+Schnittstelle:
+-> Über ProviderConfig werden die Attribute 'base_url', 'api_key', 'model' und 'provider' übergeben. Dabei sind alles Strings, 'provider' ist als Plaintext geschrieben 'openai' / 'anthropic'. Schließlich wird das Providerobjekt instanziert durch das Übergeben des ProviderConfig-Objektes durch Provider.from_config().
+Die Providerinstanz wird als model_engine an das Raesoning übergeben.
+
+
+Diese Funktion muss folgende Variablen + Datentypen empfangen: 
+- user_prompt (str)
+- system_prompt (str)
+
+Der User muss sicherstellen, dass der eigentliche LLM-Aufruf in dieser Funktion erfolgt und das 'return'-Statement der Funktion die Antwort des LLMs als String zurückgibt. 
+
+
+Der unkomplizierteste Weg liegt in der passenden Nutzung des internen 'Provider'-Moduls. Dieses ist ausdrücklich auf die Kompatibilität ausgerichtet und enthält eigene Fehler sowie Infrastruktur über eigene DTOs. Zudem bietet es sehr hohe Abstraktion bei minimalster Eingabe.
+
+--------------------------
+
+Die Reasoner-eigene Funktion namens "think()" erwartet die initiale Nuteranfrage (user_prompt).
+
+Sie ruft aktuell vier mal die Funktion 'generate()' aus dem übergebenen Ojekt auf und liefert am Ende die finale Antwort als String an den Aufrufer.
+Durch das Flag 'print_thinking_steps' (standardmäßig False) werden die "Thinking-Steps" ausgegeben.

multidimensions-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "multidimensions"
+version = "0.1.0"
+description = "Framework for Reasoning and Agentic base"
+readme = "README.md"
+requires-python = ">=3.10"
+
+authors = [
+    { name = "Alexander Baum" }
+]
+
+dependencies = [
+    "openai",
+    "anthropic",
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

multidimensions-0.1.0/setup.cfg

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

multidimensions-0.1.0/src/multidimensions/__init__.py

@@ -0,0 +1,13 @@
+from .reasoning.reasoner import Reasoner
+from .providers.provider_config import ProviderConfig
+from .providers.providers import Provider
+from .providers.provider_errors import UnsupportedFeatureError
+from .providers.infrastructure_dtos import LLMResponse
+
+__all__ = [
+    "Reasoner",
+    "Provider",
+    "ProviderConfig",
+    "UnsupportedFeatureError",
+    "LLMResponse"
+]

multidimensions-0.1.0/src/multidimensions/providers/__init__.py

@@ -0,0 +1,6 @@
+from .provider_config import ProviderConfig
+from .providers import Provider
+from .provider_errors import UnsupportedFeatureError
+from .infrastructure_dtos import LLMResponse
+
+__all__ = ["ProviderConfig", "Provider", "UnsupportedFeatureError", "LLMResponse"]

multidimensions-0.1.0/src/multidimensions/providers/infrastructure_dtos.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class LLMResponse:
+    answer: str 
+    confidence_score: float | None = None
+    confidence_level: str = ""

multidimensions-0.1.0/src/multidimensions/providers/provider_config.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+
+
+
+ALLOWED_PROVIDERS = ('openai', 'anthropic')         # Konstante für das Überprüfen in der __post_init__() 
+ProviderName = Literal['openai', 'anthropic']       # Literal als Typehinting für den User
+
+
+@dataclass(frozen=True, slots=True) # Mit 'frozen' wird die dataclass unveränderlich, mit Slots wirds Tippfehlersicher und schneller, da es kein dict mehr ist.
+class ProviderConfig:
+    # Provider ist das AI-Lab 'openai' / 'anthropic' | aktuell noch nicht: 'gemini' / 'x' / 'mistral'
+    provider: ProviderName
+   
+    model: str
+    base_url: str
+    api_key: str = field(repr=False)
+    max_retries: int = 2
+    timeout: float = 600.0
+
+    
+    
+
+    def __post_init__(self) -> None:
+        if self.provider not in ALLOWED_PROVIDERS:
+            raise ValueError(
+                f"Ungültiger Provider {self.provider!r}. "
+                f"Erlaubt sind: {", " .join(ALLOWED_PROVIDERS)}."
+            )

multidimensions-0.1.0/src/multidimensions/providers/provider_errors.py

@@ -0,0 +1,5 @@
+
+
+# Klasse zur Fehlerbehandlung durch Anthropic
+class UnsupportedFeatureError(Exception):
+    pass

multidimensions-0.1.0/src/multidimensions/providers/providers.py

@@ -0,0 +1,225 @@
+from abc import ABC, abstractmethod
+from .provider_config import ProviderConfig
+from .provider_errors import UnsupportedFeatureError
+from .infrastructure_dtos import LLMResponse
+
+import math
+from openai import OpenAI
+from anthropic import Anthropic
+
+
+
+class Provider(ABC):
+    def __init__(self, config: ProviderConfig):
+        self.config = config
+    
+
+    def _validate_prompt(self, prompt: str) -> None:
+        if not prompt.strip():
+            raise ValueError(
+                "Der Prompt darf nicht leer sein."
+            )
+
+
+    # Factory-Methode, die für die öffentliche API zur Konfiguration genutzt werden kann
+    # Der Nutzer furft diese Funktion auf und erhält die fertige Provider-Klasse
+    @classmethod
+    def from_config(cls, provider_config: ProviderConfig) -> "Provider":
+        provider_classes = {
+            "openai": OpenAIProvider,
+            "anthropic": AnthropicProvider,
+        }
+
+        try:
+            provider_class = provider_classes[provider_config.provider]
+        except KeyError:
+            raise KeyError(
+                f"Unbekannter Provider: {provider_config.provider}"
+            )
+        
+        return provider_class(provider_config)
+
+
+    @abstractmethod
+    def generate(self, system_prompt: str, user_prompt: str, temperature: float = 0.5) -> LLMResponse:
+        ...
+
+    
+    @abstractmethod
+    def generate_with_logprobs(self, system_prompt: str, user_prompt, temperature: float = 0.5) -> LLMResponse:
+        ...
+
+
+# Provider-Klasse 'OpenAI'
+class OpenAIProvider(Provider):
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.client = OpenAI(
+            base_url=config.base_url,
+            api_key=config.api_key,
+            max_retries=config.max_retries,
+            timeout=config.timeout
+        )
+    
+
+    def generate(self, system_prompt: str, user_prompt: str, temperature: float = 0.5) -> LLMResponse:
+
+        # Für diese beiden Funktionen gibt es keinen try-block, da der Fehler weiter hoch blubbern soll.
+        self._validate_prompt(prompt=system_prompt)
+        self._validate_prompt(prompt=user_prompt)
+
+
+        response = self.client.responses.create(
+            model=self.config.model,
+            temperature=temperature,
+            input=[
+                {
+                    "role": "system",
+                    "content": [
+                        {
+                            "type": "input_text",
+                            "text": system_prompt,
+                        }
+                    ],
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "input_text",
+                            "text": user_prompt,
+                        }
+                    ],
+                },
+            ],
+        )
+
+        
+        # Das Response-DTO ist wird befüllt und schließlich im return-Statement übergeben
+        response_dto = LLMResponse(
+            answer=response.output_text
+        )
+
+        return response_dto
+    
+
+
+    # LLM-Call mit Logprobs (Tokenwahrscheinlichkeit)
+    def generate_with_logprobs(self, system_prompt: str, user_prompt: str, temperature: float = 0.5) -> LLMResponse:
+
+        # Für diese beiden Funktionen gibt es keinen try-block, da der Fehler weiter hoch blubbern soll.
+        self._validate_prompt(prompt=system_prompt)
+        self._validate_prompt(prompt=user_prompt)
+
+
+        response = self.client.chat.completions.create(
+            model=self.config.model,
+            temperature=temperature,
+            logprobs=True,
+
+            messages=[
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": user_prompt
+                }
+            ],
+        )
+
+        answer = response.choices[0].message.content or ""
+
+
+        # Fehler abfangen, falls doch keine Logprobs geliefert werden können.
+        if response.choices[0].logprobs is None or response.choices[0].logprobs.content is None:
+            raise UnsupportedFeatureError
+
+
+        token_probs = []
+        for token in response.choices[0].logprobs.content:
+            token_probs.append(math.exp(token))
+
+        confidence_score = sum(token_probs) / len(token_probs)
+
+        
+        response_dto = LLMResponse(
+            answer=answer,
+            confidence_score=confidence_score
+        )
+
+        return response_dto
+        
+
+
+
+# Provider-Klasse 'Anthropic'
+class AnthropicProvider(Provider):
+    def __init__(self, config):
+        super().__init__(config)
+
+        self.client = Anthropic(
+            base_url=self.config.base_url,
+            api_key=self.config.api_key,
+            timeout=self.config.timeout,
+            max_retries=self.config.max_retries
+        )
+    
+
+    def generate(self, system_prompt: str, user_prompt: str, temperature: float = 0.5):
+
+        # Für diese beiden Funktionen gibt es keinen try-block, da der Fehler weiter hoch blubbern soll.
+        self._validate_prompt(prompt=system_prompt)
+        self._validate_prompt(prompt=user_prompt)
+
+
+        response = self.client.messages.create(
+            model=self.config.model,
+            max_tokens=2096,
+            system=system_prompt,
+            temperature=temperature,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": user_prompt,
+                        }
+                    ],
+                }
+            ],
+        )
+
+        text_parts = []
+
+        for block in response.content:
+            if block.type == "text":
+                text_parts.append(block.text)
+
+        if not text_parts:
+            raise RuntimeError(
+                "Anthropic hat keine Textausgabe zurückgegeben."
+            )
+        
+        answer = "".join(text_parts)
+        
+        response_dto = LLMResponse(
+            answer=answer
+        )
+
+
+        return response_dto
+    
+
+    # Wahrscheinlichkeitsrückgabe (Nur Fehlerbehandlung, da Anthropic das nicht anbietet)
+    def generate_with_logprobs(self, system_prompt: str, user_prompt: str, temperature: float = 0.5):
+        
+        raise UnsupportedFeatureError(
+            "Anthropic-API ermöglicht derzeitig nicht das Extrahieren von Tokenwahrscheinlichkeiten."
+        )
+    
+
+    

multidimensions-0.1.0/src/multidimensions/reasoning/__init__.py

@@ -0,0 +1,3 @@
+from .reasoner import Reasoner
+
+__all__ = ["Reasoner"]

multidimensions-0.1.0/src/multidimensions/reasoning/prompts.py

@@ -0,0 +1,77 @@
+class Prompts:
+
+    @staticmethod
+    def get_analysis_prompt() -> str:
+        return (
+            "Analysiere ausschließlich die Nutzeranfrage.\n"
+            "Bestimme Ziel, Anforderungen, Einschränkungen, Kontext und etwaige Unklarheiten.\n"
+            "Löse die Aufgabe nicht.\n"
+            "Erstelle keinen Lösungsplan.\n"
+            "Gib keine finale Antwort an den Nutzer.\n"
+            "Dein Output ist nur ein interner Analysebericht.\n"
+            "Struktur:\n"
+            "1. Ziel der Anfrage\n"
+            "2. Anforderungen\n"
+            "3. Einschränkungen\n"
+            "4. Unklarheiten oder Annahmen\n"
+            "5. Relevanter Kontext\n"
+        )
+
+    @staticmethod
+    def get_planning_prompt() -> str:
+        return (
+            "Erstelle ausschließlich einen Lösungsplan auf Grundlage der Nutzeranfrage "
+            "und der Analyse.\n"
+            "Löse die Aufgabe nicht.\n"
+            "Formuliere keine Antwort an den Nutzer.\n"
+            "Der Output ist ein interner Arbeitsplan für die nächste Stufe.\n"
+            "Zerlege die Aufgabe in konkrete, aufeinander aufbauende Schritte.\n"
+            "Berücksichtige Anforderungen, Einschränkungen und mögliche Fehlerquellen.\n"
+            "Struktur:\n"
+            "1. Vorgehensstrategie\n"
+            "2. Benötigte Informationen oder Annahmen\n"
+            "3. Arbeitsschritte\n"
+            "4. Qualitätskriterien für die Lösung\n"
+        )
+
+    @staticmethod
+    def get_solving_prompt() -> str:
+        return (
+            "Erarbeite ausschließlich die fachliche Roh-Lösung.\n"
+            "Nutze dafür die Nutzeranfrage, die Analyse und den Lösungsplan.\n"
+            "Dies ist nicht die finale Antwort an den Nutzer.\n"
+            "Formuliere nicht didaktisch, nicht rhetorisch und nicht als Chat-Antwort.\n"
+            "Keine Einleitung, kein Fazit, keine direkte Ansprache des Nutzers.\n"
+            "Arbeite nur den inhaltlichen Kern aus.\n"
+            "Der Output soll Rohmaterial für die finale Antwort sein.\n"
+            "Erlaubt sind:\n"
+            "- zentrale Aussagen\n"
+            "- notwendige Schritte\n"
+            "- technische Details\n"
+            "- Beispiele im Rohformat\n"
+            "- wichtige Einschränkungen\n"
+            "- Fehlerquellen\n"
+            "Nicht erlaubt sind:\n"
+            "- fertige Antwortabsätze\n"
+            "- freundliche Einleitungen\n"
+            "- Zusammenfassungen für den Nutzer\n"
+            "- Meta-Kommentare über die eigene Arbeit\n"
+            "Struktur:\n"
+            "1. Kernlösung\n"
+            "2. Begründung\n"
+            "3. Wichtige Details\n"
+            "4. Mögliche Einschränkungen oder Risiken\n"
+        )
+
+    @staticmethod
+    def get_answer_prompt() -> str:
+        return (
+            "Formuliere ausschließlich die finale Antwort für den Nutzer.\n"
+            "Nutze dafür die erarbeitete Roh-Lösung.\n"
+            "Gib keine Analyse, keinen Plan und keine internen Arbeitsschritte wieder.\n"
+            "Füge keine neuen fachlichen Punkte hinzu, außer sie sind zwingend nötig, "
+            "um die Roh-Lösung verständlich zu machen.\n"
+            "Beantworte die ursprüngliche Nutzeranfrage direkt und vollständig.\n"
+            "Passe Detailgrad, Sprache und Struktur an die Anfrage an.\n"
+            "Der Output darf nur die fertige Nutzerantwort enthalten.\n"
+        )

multidimensions-0.1.0/src/multidimensions/reasoning/protocols.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from typing import Protocol, TYPE_CHECKING
+
+if TYPE_CHECKING: 
+    from ..providers import LLMResponse
+    
+
+
+class LanguageModel(Protocol):
+    def generate(self, *, system_prompt: str, user_prompt: str) -> LLMResponse:
+        ... # Elipsis wird hier nur als Signaturbeschreibung verwendet! statt 'pass' "Dieser Methodenrumpf tut nichts."
+
+    
+    
+    def generate_with_logprobs(self, *, system_prompt: str, user_prompt: str, temperature: float = 0.5) -> LLMResponse:
+        ...

multidimensions-0.1.0/src/multidimensions/reasoning/reasoner.py

@@ -0,0 +1,188 @@
+from .protocols import LanguageModel
+from .prompts import Prompts
+from ..providers import UnsupportedFeatureError, LLMResponse
+
+from dataclasses import replace
+
+class Reasoner:
+    def __init__(self, *, model_engine: LanguageModel):
+        
+        self.model_engine=model_engine
+    
+
+    def think(self, user_prompt: str, print_thinking_steps: bool = False) -> str:
+        """
+        !!Die generate-Methode in model_engine muss im return-Statement einen String zurückgeben 
+        1. Analyse
+        2. Planung
+        3. Lösung
+        4. Antwort
+        """
+        
+        while True:
+            analysis_response: LLMResponse = self._analyse(user_prompt=user_prompt)
+            analysis_response: LLMResponse = self.__validate_response(response_dto=analysis_response, reasoning_mode="Analysephase", print_thinking_steps=print_thinking_steps)
+
+
+            print(f"DEBUG: CONFIDENCE_LEVEL: {analysis_response.confidence_level}")
+            
+            if analysis_response.confidence_level != "RETRY":
+                break                
+
+            
+
+        while True:
+            planning_response: LLMResponse = self._planning(user_prompt=user_prompt, analysis_response=analysis_response)
+            planning_response: LLMResponse = self.__validate_response(response_dto=planning_response, reasoning_mode="Planungsphase", print_thinking_steps=print_thinking_steps)
+
+            print(f"DEBUG: CONFIDENCE_LEVEL: {planning_response.confidence_level}")
+
+            if planning_response.confidence_level != "RETRY":
+                break
+        
+        while True:
+            solution_response: LLMResponse = self._solve(user_prompt=user_prompt, analysis_response=analysis_response, planning_response=planning_response)
+            solution_response: LLMResponse = self.__validate_response(response_dto=solution_response, reasoning_mode="Lösungsphase", print_thinking_steps=print_thinking_steps)
+            
+            print(f"DEBUG: CONFIDENCE_LEVEL: {solution_response.confidence_level}")
+            
+            if solution_response.confidence_level != "RETRY":
+                break
+            
+        
+        
+        final_answer_response: LLMResponse = self._write_answer(user_prompt=user_prompt, solution_response=solution_response)
+
+
+        # TODO
+            # Hier kommt die Logik rein für die Abfrage mit / ohne finale Antwort
+
+
+        # Rückgabe der finalen Antwort
+        return final_answer_response.answer
+
+
+    
+
+    # Analyse-Funktion
+    def _analyse(self, user_prompt: str) -> LLMResponse:
+        # Wir holen uns aus der Prompt-Klasse den Analyse-Prompt
+        system_prompt = Prompts.get_analysis_prompt()
+
+        # Eigentlicher LLM-Call -> läuft über den LLM-Provider
+        try:
+            return self.model_engine.generate_with_logprobs(system_prompt=system_prompt, user_prompt=user_prompt)
+        
+        # Falls der Provider keine Logprobs ermöglicht, wird die simple generate-methode genommen.        
+        except UnsupportedFeatureError as e:
+            return self.model_engine.generate(system_prompt=system_prompt, user_prompt=user_prompt)
+
+
+
+    # Planungs-Funktion
+    def _planning(self, user_prompt: str, analysis_response: LLMResponse) -> LLMResponse:
+        # Wir holen uns aus de Prompt-Klasse den Planungs-Prompt
+        system_prompt = Prompts.get_planning_prompt()
+
+        
+        # Hier bauen wir uns den finalen user_prompt
+        user_prompt = f"Initiale Useranfrage: {user_prompt} | Analyse des Falls: {analysis_response.answer} | {analysis_response.confidence_level}"
+
+        # Eigentlicher LLM-Call -> läuft über den LLM-Provider
+        try:
+            return self.model_engine.generate_with_logprobs(system_prompt=system_prompt, user_prompt=user_prompt)
+        
+        # Falls der Provider keine Logprobs ermöglicht, wird die simple generate-methode genommen.        
+        except UnsupportedFeatureError as e:
+            return self.model_engine.generate(system_prompt=system_prompt, user_prompt=user_prompt)
+        
+    
+
+    # Lösungs-Funktion
+    def _solve(self, user_prompt: str, analysis_response: LLMResponse, planning_response: LLMResponse) -> LLMResponse:
+        # Wir holen uns aus der Prompt-Klasse den Planungs-Prompt
+        system_prompt = Prompts.get_solving_prompt()
+
+        # Hier bauen wir uns den finalen user_prompt
+        user_prompt = f"Initiale Useranfrage: {user_prompt} | Analyse des Falls: {analysis_response.answer} | {analysis_response.confidence_level} | Planung des Falls: {planning_response.answer} | {planning_response.confidence_level}"
+
+        # Eigentlicher LLM-Call -> läuft über den LLM-Provider
+        try:
+            return self.model_engine.generate_with_logprobs(system_prompt=system_prompt, user_prompt=user_prompt)
+        
+        except UnsupportedFeatureError as e:
+            return self.model_engine.generate(system_prompt=system_prompt, user_prompt=user_prompt)
+
+
+
+    # Antwortfunktion (Ausformulierung), wobei nur die Lösung übergeben wird, nicht die anderen Reasoningsteps.
+    def _write_answer(self, user_prompt: str, solution_response: LLMResponse, ) -> LLMResponse:
+        # Wir holen uns aus der Prompt-Klasse den Planungs-Prompt
+        system_prompt = Prompts.get_answer_prompt()
+
+        # Hier bauen wir uns den finalen user_prompt
+        user_prompt = f"Initiale Useranfrage: {user_prompt} | Die konkrete Lösung: {solution_response.answer} | {solution_response.confidence_level}"
+
+        # Eigentlicher LLM-Call -> läuft über den LLM-Provider
+        try:
+            return self.model_engine.generate_with_logprobs(system_prompt=system_prompt, user_prompt=user_prompt)
+
+        except UnsupportedFeatureError as e:
+            return self.model_engine.generate(system_prompt=system_prompt, user_prompt=user_prompt)
+
+
+
+
+    # Validierung. Aktuell der Confidence und Umwandlung in ein LLM-Lesbares Format.
+    def __validate_response(self, print_thinking_steps, response_dto: LLMResponse, reasoning_mode: str, minimum_confidence: float = 0.55):
+
+        # Mapping des Confidencelevels auf natürliche Sprache, aktuell hat minimum_confidence noch keinen direkten Einfluss!
+        # 'reasoning_mode' wird später Einfluss haben, da jeweilige Modi aufgrund der confidence anders bewetet werden!
+
+        mapping = [
+            (0.85, "Das Modell ist sich seiner Generierung sehr sicher, hier ist der Confidence Score: "),
+            (0.7, "Das Modell hat beim Confidence-Thresholding einen Normalen Wert erreicht."),
+            (0.55, "Vosicht: Das Modell war sich bei seiner Generierung unsicher."),
+            
+            # Für zukünftige Operationen, könnte eine vierte Stufe sinnvoll sein, auch wenn der Wert von 0.55 direkt zu einem Retry führt.
+            (0.0, "Problematisch: Das Modell hat bei der Generierung der letzen Stufe des mehrstufigen Reasonings eine kritische Confidence.")
+        ]
+        
+        # Check, ob überhaupt confidence_score vorhanden ist. Dann erfolgt der Abgleich mit der Map
+        if response_dto.confidence_score is not None:
+
+            # Wenn die Confidence unter die Erlaubte fällt, gibt es ein Update und das DTO wird zurückgegeben.
+            if response_dto.confidence_score <= minimum_confidence:
+                level = "RETRY"
+                response_dto = replace(response_dto, confidence_level=level)
+                return response_dto
+
+            # Wenn die Confidence nicht unter die Erlaubte fällt, wird eines der anderen Level ausgewählt.
+            for threshold, label in mapping:
+                if response_dto.confidence_score >= threshold:
+                    level = label
+                    
+                    # Zusaztaussage, damit das Modell beim Reasoning dem Verlauf folegen kann. 
+                    # Standardwert von LLMResponse.confidence_level wurde auf "" gesetzt.
+                    confidence_level = (
+                        f"Confidence Level der {reasoning_mode}: {level}"
+                    )
+
+                    response_dto = replace(response_dto, confidence_level=confidence_level)
+
+                    # Check, falls User die Thinking-Steps ausgedruckt haben möchte.
+                    if print_thinking_steps:
+                        print(response_dto.answer)
+
+                    return response_dto
+        
+
+        # Wenn 'confidence_score' leer ist. 
+        else:
+            # Check, falls User die Thinking-Steps ausgedruckt haben möchte.
+            if print_thinking_steps:
+                print(response_dto.answer)
+
+            return response_dto
+            
+    

multidimensions-0.1.0/src/multidimensions.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: multidimensions
+Version: 0.1.0
+Summary: Framework for Reasoning and Agentic base
+Author: Alexander Baum
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai
+Requires-Dist: anthropic
+Dynamic: license-file
+
+Dieses Framework bildet die Grundlage für Multistep-Reasoning und den Bau von Agenten.
+
+Aktuell wurde ein vierstufiges Reasoning eingefügt.
+
+1. Analyse
+2. Planung
+3. Lösung 
+4. Fertige Antwort
+
+Die derzeitigen Prompts für die jeweiligen Schritte sind minimal gestaltet. Der aktuelle Fokus liegt auf dem sicherstellen der Funktionalität sowie dem Implementieren neuer Funktionen. Im späteren Verlauf wird das konkrete Prompting für das LLM ausgearbeitet.
+
+
+Schnittstelle:
+-> Über ProviderConfig werden die Attribute 'base_url', 'api_key', 'model' und 'provider' übergeben. Dabei sind alles Strings, 'provider' ist als Plaintext geschrieben 'openai' / 'anthropic'. Schließlich wird das Providerobjekt instanziert durch das Übergeben des ProviderConfig-Objektes durch Provider.from_config().
+Die Providerinstanz wird als model_engine an das Raesoning übergeben.
+
+
+Diese Funktion muss folgende Variablen + Datentypen empfangen: 
+- user_prompt (str)
+- system_prompt (str)
+
+Der User muss sicherstellen, dass der eigentliche LLM-Aufruf in dieser Funktion erfolgt und das 'return'-Statement der Funktion die Antwort des LLMs als String zurückgibt. 
+
+
+Der unkomplizierteste Weg liegt in der passenden Nutzung des internen 'Provider'-Moduls. Dieses ist ausdrücklich auf die Kompatibilität ausgerichtet und enthält eigene Fehler sowie Infrastruktur über eigene DTOs. Zudem bietet es sehr hohe Abstraktion bei minimalster Eingabe.
+
+--------------------------
+
+Die Reasoner-eigene Funktion namens "think()" erwartet die initiale Nuteranfrage (user_prompt).
+
+Sie ruft aktuell vier mal die Funktion 'generate()' aus dem übergebenen Ojekt auf und liefert am Ende die finale Antwort als String an den Aufrufer.
+Durch das Flag 'print_thinking_steps' (standardmäßig False) werden die "Thinking-Steps" ausgegeben.

multidimensions-0.1.0/src/multidimensions.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/multidimensions/__init__.py
+src/multidimensions.egg-info/PKG-INFO
+src/multidimensions.egg-info/SOURCES.txt
+src/multidimensions.egg-info/dependency_links.txt
+src/multidimensions.egg-info/requires.txt
+src/multidimensions.egg-info/top_level.txt
+src/multidimensions/providers/__init__.py
+src/multidimensions/providers/infrastructure_dtos.py
+src/multidimensions/providers/provider_config.py
+src/multidimensions/providers/provider_errors.py
+src/multidimensions/providers/providers.py
+src/multidimensions/reasoning/__init__.py
+src/multidimensions/reasoning/prompts.py
+src/multidimensions/reasoning/protocols.py
+src/multidimensions/reasoning/reasoner.py

multidimensions-0.1.0/src/multidimensions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

multidimensions-0.1.0/src/multidimensions.egg-info/requires.txt

@@ -0,0 +1,2 @@
+openai
+anthropic

multidimensions-0.1.0/src/multidimensions.egg-info/top_level.txt

@@ -0,0 +1 @@
+multidimensions