asterinis 0.0.1__tar.gz

asterinis-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Irena Popova
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

asterinis-0.0.1/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: asterinis
+Version: 0.0.1
+Summary: Python framework for AI orchestration, RAG, NLP integration, agent routing, and explainable AI.
+Author: Irena Popova
+License: MIT
+Project-URL: Homepage, https://github.com/irenapopova/asterinis
+Project-URL: Repository, https://github.com/irenapopova/asterinis
+Project-URL: Issues, https://github.com/irenapopova/asterinis/issues
+Keywords: ai,rag,nlp,agents,llm,orchestration,flair,machine-learning,python
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: flair
+Requires-Dist: flair>=0.15; extra == "flair"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# asterinis
+# Asterinis
+
+**Asterinis** is an early-stage Python framework for connecting NLP, retrieval-augmented generation (RAG), AI agents, routing logic, explainability, and LLM services through a unified backend nexus.
+
+The project is designed as a lightweight orchestration layer that can connect different AI and NLP components without locking an application to a single model provider or framework.
+
+## Current Status
+
+Asterinis is currently in an early development stage.
+
+The first public release focuses on the core framework structure, including:
+
+* Nexus orchestration
+* Rule-based routing
+* Connector interfaces
+* Processing context
+* Pipelines
+* Hooks
+* Result objects
+* Optional NLP integrations
+
+More advanced RAG, agent orchestration, adaptive routing, evaluation, and explainability features are planned for future releases.
+
+## Installation
+
+The package will be installable from PyPI:
+
+```bash
+pip install asterinis
+```
+
+For optional Flair NLP support:
+
+```bash
+pip install "asterinis[flair]"
+```
+
+## Basic Usage
+
+```python
+from asterinis import Nexus
+
+nexus = Nexus()
+
+result = nexus.process(
+    "Search documents about multilingual NLP."
+)
+
+print(result.route)
+print(result.payload)
+```
+
+Asterinis can route requests toward different processing paths such as:
+
+```text
+rag
+nlp
+agent
+llm
+```
+
+## Flair Integration
+
+Asterinis supports Flair as an optional NLP connector.
+
+```python
+from asterinis import Nexus
+from asterinis.integrations import FlairConnector
+
+nexus = Nexus()
+
+nexus.register_connector(
+    "nlp",
+    FlairConnector("ner")
+)
+
+result = nexus.process(
+    "Deutsche Bank is based in Frankfurt."
+)
+
+print(result.to_dict())
+```
+
+Flair is an independent open-source NLP framework and is not part of Asterinis. Asterinis provides an integration layer that allows Flair models to participate in a broader orchestration pipeline.
+
+## Architecture
+
+```text
+Application
+    ↓
+Asterinis Nexus
+    ↓
+Router
+    ↓
+┌──────────┬──────────┬──────────┬──────────┐
+│   NLP    │   RAG    │  Agents  │   LLM    │
+└──────────┴──────────┴──────────┴──────────┘
+    ↓
+Connectors / Integrations
+```
+
+The goal is to allow developers to plug different AI systems into a consistent interface.
+
+## Project Structure
+
+```text
+src/
+└── asterinis/
+    ├── __init__.py
+    ├── nexus.py
+    ├── router.py
+    ├── connectors.py
+    ├── context.py
+    ├── pipeline.py
+    ├── hooks.py
+    ├── result.py
+    ├── config.py
+    ├── exceptions.py
+    └── integrations/
+        ├── __init__.py
+        └── flair.py
+```
+
+## Roadmap
+
+Future development may include:
+
+* advanced RAG routing
+* retrieval quality evaluation
+* agent orchestration
+* adaptive routing policies
+* explainability
+* confidence-aware decision logic
+* additional NLP integrations
+* LLM provider connectors
+* evaluation tools
+* persistent context and memory
+* asynchronous pipelines
+
+## Version
+
+Current development version:
+
+```text
+0.0.1
+```
+
+## License
+
+Asterinis is released under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Author
+
+Created and maintained by **Irena Popova**, Full-Stack Developer and AI/NLP, RAG, and adaptive systems researcher.

asterinis-0.0.1/README.md

@@ -0,0 +1,155 @@
+# asterinis
+# Asterinis
+
+**Asterinis** is an early-stage Python framework for connecting NLP, retrieval-augmented generation (RAG), AI agents, routing logic, explainability, and LLM services through a unified backend nexus.
+
+The project is designed as a lightweight orchestration layer that can connect different AI and NLP components without locking an application to a single model provider or framework.
+
+## Current Status
+
+Asterinis is currently in an early development stage.
+
+The first public release focuses on the core framework structure, including:
+
+* Nexus orchestration
+* Rule-based routing
+* Connector interfaces
+* Processing context
+* Pipelines
+* Hooks
+* Result objects
+* Optional NLP integrations
+
+More advanced RAG, agent orchestration, adaptive routing, evaluation, and explainability features are planned for future releases.
+
+## Installation
+
+The package will be installable from PyPI:
+
+```bash
+pip install asterinis
+```
+
+For optional Flair NLP support:
+
+```bash
+pip install "asterinis[flair]"
+```
+
+## Basic Usage
+
+```python
+from asterinis import Nexus
+
+nexus = Nexus()
+
+result = nexus.process(
+    "Search documents about multilingual NLP."
+)
+
+print(result.route)
+print(result.payload)
+```
+
+Asterinis can route requests toward different processing paths such as:
+
+```text
+rag
+nlp
+agent
+llm
+```
+
+## Flair Integration
+
+Asterinis supports Flair as an optional NLP connector.
+
+```python
+from asterinis import Nexus
+from asterinis.integrations import FlairConnector
+
+nexus = Nexus()
+
+nexus.register_connector(
+    "nlp",
+    FlairConnector("ner")
+)
+
+result = nexus.process(
+    "Deutsche Bank is based in Frankfurt."
+)
+
+print(result.to_dict())
+```
+
+Flair is an independent open-source NLP framework and is not part of Asterinis. Asterinis provides an integration layer that allows Flair models to participate in a broader orchestration pipeline.
+
+## Architecture
+
+```text
+Application
+    ↓
+Asterinis Nexus
+    ↓
+Router
+    ↓
+┌──────────┬──────────┬──────────┬──────────┐
+│   NLP    │   RAG    │  Agents  │   LLM    │
+└──────────┴──────────┴──────────┴──────────┘
+    ↓
+Connectors / Integrations
+```
+
+The goal is to allow developers to plug different AI systems into a consistent interface.
+
+## Project Structure
+
+```text
+src/
+└── asterinis/
+    ├── __init__.py
+    ├── nexus.py
+    ├── router.py
+    ├── connectors.py
+    ├── context.py
+    ├── pipeline.py
+    ├── hooks.py
+    ├── result.py
+    ├── config.py
+    ├── exceptions.py
+    └── integrations/
+        ├── __init__.py
+        └── flair.py
+```
+
+## Roadmap
+
+Future development may include:
+
+* advanced RAG routing
+* retrieval quality evaluation
+* agent orchestration
+* adaptive routing policies
+* explainability
+* confidence-aware decision logic
+* additional NLP integrations
+* LLM provider connectors
+* evaluation tools
+* persistent context and memory
+* asynchronous pipelines
+
+## Version
+
+Current development version:
+
+```text
+0.0.1
+```
+
+## License
+
+Asterinis is released under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Author
+
+Created and maintained by **Irena Popova**, Full-Stack Developer and AI/NLP, RAG, and adaptive systems researcher.

asterinis-0.0.1/pyproject.toml

@@ -0,0 +1,71 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "asterinis"
+version = "0.0.1"
+description = "Python framework for AI orchestration, RAG, NLP integration, agent routing, and explainable AI."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+
+authors = [
+    { name = "Irena Popova" }
+]
+
+keywords = [
+    "ai",
+    "rag",
+    "nlp",
+    "agents",
+    "llm",
+    "orchestration",
+    "flair",
+    "machine-learning",
+    "python"
+]
+
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+dependencies = []
+
+
+[project.optional-dependencies]
+flair = [
+    "flair>=0.15"
+]
+
+dev = [
+    "pytest>=8.0",
+    "build>=1.2",
+    "twine>=5.0"
+]
+
+
+[project.urls]
+Homepage = "https://github.com/irenapopova/asterinis"
+Repository = "https://github.com/irenapopova/asterinis"
+Issues = "https://github.com/irenapopova/asterinis/issues"
+
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]

asterinis-0.0.1/setup.cfg

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

asterinis-0.0.1/src/asterinis/__init__.py

@@ -0,0 +1,33 @@
+from .config import AsterinisConfig
+from .connectors import Connector, EchoConnector
+from .context import NexusContext
+from .exceptions import (
+    AsterinisError,
+    ConnectorError,
+    PipelineError,
+    RoutingError,
+)
+from .hooks import HookManager
+from .nexus import Nexus
+from .pipeline import Pipeline
+from .result import NexusResult
+from .router import Router
+
+
+__version__ = "0.0.1"
+
+__all__ = [
+    "AsterinisConfig",
+    "AsterinisError",
+    "Connector",
+    "ConnectorError",
+    "EchoConnector",
+    "HookManager",
+    "Nexus",
+    "NexusContext",
+    "NexusResult",
+    "Pipeline",
+    "PipelineError",
+    "Router",
+    "RoutingError",
+]

asterinis-0.0.1/src/asterinis/config.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class AsterinisConfig:
+    default_route: str = "llm"
+    enable_rag: bool = True
+    enable_nlp: bool = True
+    enable_agents: bool = True
+    debug: bool = False

asterinis-0.0.1/src/asterinis/connectors.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Connector(ABC):
+    """
+    Base connector interface.
+
+    Connectors allow Asterinis to communicate with
+    external NLP, RAG, agent, or LLM systems.
+    """
+
+    name: str = "connector"
+
+    @abstractmethod
+    def execute(self, payload: Any) -> Any:
+        raise NotImplementedError
+
+
+class EchoConnector(Connector):
+    name = "echo"
+
+    def execute(self, payload: Any) -> Any:
+        return {
+            "connector": self.name,
+            "payload": payload,
+        }

asterinis-0.0.1/src/asterinis/context.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class NexusContext:
+    input_text: str
+    metadata: dict[str, Any] = field(default_factory=dict)
+    state: dict[str, Any] = field(default_factory=dict)
+
+    def set(self, key: str, value: Any) -> None:
+        self.state[key] = value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self.state.get(key, default)

asterinis-0.0.1/src/asterinis/exceptions.py

@@ -0,0 +1,14 @@
+class AsterinisError(Exception):
+    """Base exception for Asterinis."""
+
+
+class RoutingError(AsterinisError):
+    """Raised when routing cannot be completed."""
+
+
+class ConnectorError(AsterinisError):
+    """Raised when a connector fails."""
+
+
+class PipelineError(AsterinisError):
+    """Raised when a pipeline step fails."""

asterinis-0.0.1/src/asterinis/hooks.py

@@ -0,0 +1,18 @@
+from collections import defaultdict
+from collections.abc import Callable
+from typing import Any
+
+
+Hook = Callable[..., Any]
+
+
+class HookManager:
+    def __init__(self):
+        self._hooks: dict[str, list[Hook]] = defaultdict(list)
+
+    def register(self, event: str, callback: Hook) -> None:
+        self._hooks[event].append(callback)
+
+    def emit(self, event: str, **kwargs: Any) -> None:
+        for callback in self._hooks.get(event, []):
+            callback(**kwargs)

asterinis-0.0.1/src/asterinis/integrations/__init__.py

@@ -0,0 +1,3 @@
+from .flair import FlairConnector
+
+__all__ = ["FlairConnector"]

asterinis-0.0.1/src/asterinis/integrations/flair.py

@@ -0,0 +1,49 @@
+# src/asterinis/integrations/flair.py
+
+from typing import Any
+
+from asterinis.connectors import Connector
+
+
+class FlairConnector(Connector):
+    name = "flair"
+
+    def __init__(self, model_name: str = "ner"):
+        try:
+            from flair.nn import Classifier
+        except ImportError as exc:
+            raise ImportError(
+                "Flair is not installed. "
+                'Install it with: pip install "asterinis[flair]"'
+            ) from exc
+
+        self.model_name = model_name
+        self.model = Classifier.load(model_name)
+
+    def execute(self, payload: Any) -> Any:
+        from flair.data import Sentence
+
+        text = payload["text"]
+
+        sentence = Sentence(text)
+        self.model.predict(sentence)
+
+        entities = []
+
+        for entity in sentence.get_spans("ner"):
+            label = entity.get_label("ner")
+
+            entities.append(
+                {
+                    "text": entity.text,
+                    "label": label.value,
+                    "confidence": label.score,
+                }
+            )
+
+        return {
+            "provider": "flair",
+            "model": self.model_name,
+            "text": text,
+            "entities": entities,
+        }

asterinis-0.0.1/src/asterinis/middleware.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Middleware(ABC):
+
+    def before(self, context: Any) -> Any:
+        return context
+
+    def after(self, result: Any) -> Any:
+        return result
+
+
+class TimingMiddleware(Middleware):
+
+    def before(self, context):
+        import time
+
+        context.set("_start_time", time.perf_counter())
+        return context
+
+    def after(self, result):
+        return result

asterinis-0.0.1/src/asterinis/nexus.py

@@ -0,0 +1,76 @@
+from collections.abc import Callable
+
+
+RouteRule = Callable[[str], bool]
+
+
+class Router:
+    def __init__(self, default_route: str = "llm"):
+        self.default_route = default_route
+        self._rules: list[tuple[str, RouteRule]] = []
+
+        self._register_default_rules()
+
+    def _register_default_rules(self) -> None:
+        self.add_route(
+            "rag",
+            lambda text: any(
+                word in text.lower()
+                for word in (
+                    "document",
+                    "source",
+                    "retrieve",
+                    "search",
+                )
+            ),
+        )
+
+        self.add_route(
+            "nlp",
+            lambda text: any(
+                word in text.lower()
+                for word in (
+                    "entity",
+                    "ner",
+                    "language",
+                    "nlp",
+                )
+            ),
+        )
+
+        self.add_route(
+            "agent",
+            lambda text: any(
+                word in text.lower()
+                for word in (
+                    "agent",
+                    "tool",
+                    "workflow",
+                )
+            ),
+        )
+
+    def add_route(
+        self,
+        name: str,
+        rule: RouteRule,
+        *,
+        first: bool = False,
+    ) -> None:
+        route = (name, rule)
+
+        if first:
+            self._rules.insert(0, route)
+        else:
+            self._rules.append(route)
+
+    def route(self, text: str) -> str:
+        for name, rule in self._rules:
+            if rule(text):
+                return name
+
+        return self.default_route
+
+    @property
+    def routes(self) -> list[str]:
+        return [name for name, _ in self._rules]

asterinis-0.0.1/src/asterinis/pipeline.py

@@ -0,0 +1,33 @@
+from collections.abc import Callable
+from typing import Any
+
+from .context import NexusContext
+from .exceptions import PipelineError
+
+
+PipelineStep = Callable[[NexusContext], NexusContext]
+
+
+class Pipeline:
+    def __init__(self, name: str):
+        self.name = name
+        self._steps: list[PipelineStep] = []
+
+    def add(self, step: PipelineStep) -> "Pipeline":
+        self._steps.append(step)
+        return self
+
+    def run(self, context: NexusContext) -> NexusContext:
+        try:
+            for step in self._steps:
+                context = step(context)
+
+            return context
+
+        except Exception as exc:
+            raise PipelineError(
+                f"Pipeline '{self.name}' failed."
+            ) from exc
+
+    def __len__(self) -> int:
+        return len(self._steps)

asterinis-0.0.1/src/asterinis/registry.py

@@ -0,0 +1,31 @@
+from typing import Dict
+
+from .connectors import Connector
+
+
+class ConnectorRegistry:
+    def __init__(self):
+        self._connectors: Dict[str, Connector] = {}
+
+    def register(self, name: str, connector: Connector) -> None:
+        if not name:
+            raise ValueError("Connector name cannot be empty.")
+
+        self._connectors[name] = connector
+
+    def get(self, name: str) -> Connector:
+        if name not in self._connectors:
+            raise KeyError(
+                f"Connector '{name}' is not registered."
+            )
+
+        return self._connectors[name]
+
+    def remove(self, name: str) -> None:
+        self._connectors.pop(name, None)
+
+    def exists(self, name: str) -> bool:
+        return name in self._connectors
+
+    def list(self) -> list[str]:
+        return list(self._connectors.keys())

asterinis-0.0.1/src/asterinis/result.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class NexusResult:
+    route: str
+    payload: Any
+    confidence: float = 1.0

asterinis-0.0.1/src/asterinis/router.py

@@ -0,0 +1,76 @@
+from collections.abc import Callable
+
+
+RouteRule = Callable[[str], bool]
+
+
+class Router:
+    def __init__(self, default_route: str = "llm"):
+        self.default_route = default_route
+        self._rules: list[tuple[str, RouteRule]] = []
+
+        self._register_default_rules()
+
+    def _register_default_rules(self) -> None:
+        self.add_route(
+            "rag",
+            lambda text: any(
+                word in text.lower()
+                for word in (
+                    "document",
+                    "source",
+                    "retrieve",
+                    "search",
+                )
+            ),
+        )
+
+        self.add_route(
+            "nlp",
+            lambda text: any(
+                word in text.lower()
+                for word in (
+                    "entity",
+                    "ner",
+                    "language",
+                    "nlp",
+                )
+            ),
+        )
+
+        self.add_route(
+            "agent",
+            lambda text: any(
+                word in text.lower()
+                for word in (
+                    "agent",
+                    "tool",
+                    "workflow",
+                )
+            ),
+        )
+
+    def add_route(
+        self,
+        name: str,
+        rule: RouteRule,
+        *,
+        first: bool = False,
+    ) -> None:
+        route = (name, rule)
+
+        if first:
+            self._rules.insert(0, route)
+        else:
+            self._rules.append(route)
+
+    def route(self, text: str) -> str:
+        for name, rule in self._rules:
+            if rule(text):
+                return name
+
+        return self.default_route
+
+    @property
+    def routes(self) -> list[str]:
+        return [name for name, _ in self._rules]

asterinis-0.0.1/src/asterinis.egg-info/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: asterinis
+Version: 0.0.1
+Summary: Python framework for AI orchestration, RAG, NLP integration, agent routing, and explainable AI.
+Author: Irena Popova
+License: MIT
+Project-URL: Homepage, https://github.com/irenapopova/asterinis
+Project-URL: Repository, https://github.com/irenapopova/asterinis
+Project-URL: Issues, https://github.com/irenapopova/asterinis/issues
+Keywords: ai,rag,nlp,agents,llm,orchestration,flair,machine-learning,python
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: flair
+Requires-Dist: flair>=0.15; extra == "flair"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# asterinis
+# Asterinis
+
+**Asterinis** is an early-stage Python framework for connecting NLP, retrieval-augmented generation (RAG), AI agents, routing logic, explainability, and LLM services through a unified backend nexus.
+
+The project is designed as a lightweight orchestration layer that can connect different AI and NLP components without locking an application to a single model provider or framework.
+
+## Current Status
+
+Asterinis is currently in an early development stage.
+
+The first public release focuses on the core framework structure, including:
+
+* Nexus orchestration
+* Rule-based routing
+* Connector interfaces
+* Processing context
+* Pipelines
+* Hooks
+* Result objects
+* Optional NLP integrations
+
+More advanced RAG, agent orchestration, adaptive routing, evaluation, and explainability features are planned for future releases.
+
+## Installation
+
+The package will be installable from PyPI:
+
+```bash
+pip install asterinis
+```
+
+For optional Flair NLP support:
+
+```bash
+pip install "asterinis[flair]"
+```
+
+## Basic Usage
+
+```python
+from asterinis import Nexus
+
+nexus = Nexus()
+
+result = nexus.process(
+    "Search documents about multilingual NLP."
+)
+
+print(result.route)
+print(result.payload)
+```
+
+Asterinis can route requests toward different processing paths such as:
+
+```text
+rag
+nlp
+agent
+llm
+```
+
+## Flair Integration
+
+Asterinis supports Flair as an optional NLP connector.
+
+```python
+from asterinis import Nexus
+from asterinis.integrations import FlairConnector
+
+nexus = Nexus()
+
+nexus.register_connector(
+    "nlp",
+    FlairConnector("ner")
+)
+
+result = nexus.process(
+    "Deutsche Bank is based in Frankfurt."
+)
+
+print(result.to_dict())
+```
+
+Flair is an independent open-source NLP framework and is not part of Asterinis. Asterinis provides an integration layer that allows Flair models to participate in a broader orchestration pipeline.
+
+## Architecture
+
+```text
+Application
+    ↓
+Asterinis Nexus
+    ↓
+Router
+    ↓
+┌──────────┬──────────┬──────────┬──────────┐
+│   NLP    │   RAG    │  Agents  │   LLM    │
+└──────────┴──────────┴──────────┴──────────┘
+    ↓
+Connectors / Integrations
+```
+
+The goal is to allow developers to plug different AI systems into a consistent interface.
+
+## Project Structure
+
+```text
+src/
+└── asterinis/
+    ├── __init__.py
+    ├── nexus.py
+    ├── router.py
+    ├── connectors.py
+    ├── context.py
+    ├── pipeline.py
+    ├── hooks.py
+    ├── result.py
+    ├── config.py
+    ├── exceptions.py
+    └── integrations/
+        ├── __init__.py
+        └── flair.py
+```
+
+## Roadmap
+
+Future development may include:
+
+* advanced RAG routing
+* retrieval quality evaluation
+* agent orchestration
+* adaptive routing policies
+* explainability
+* confidence-aware decision logic
+* additional NLP integrations
+* LLM provider connectors
+* evaluation tools
+* persistent context and memory
+* asynchronous pipelines
+
+## Version
+
+Current development version:
+
+```text
+0.0.1
+```
+
+## License
+
+Asterinis is released under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Author
+
+Created and maintained by **Irena Popova**, Full-Stack Developer and AI/NLP, RAG, and adaptive systems researcher.

asterinis-0.0.1/src/asterinis.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+src/asterinis/__init__.py
+src/asterinis/config.py
+src/asterinis/connectors.py
+src/asterinis/context.py
+src/asterinis/exceptions.py
+src/asterinis/hooks.py
+src/asterinis/middleware.py
+src/asterinis/nexus.py
+src/asterinis/pipeline.py
+src/asterinis/registry.py
+src/asterinis/result.py
+src/asterinis/router.py
+src/asterinis.egg-info/PKG-INFO
+src/asterinis.egg-info/SOURCES.txt
+src/asterinis.egg-info/dependency_links.txt
+src/asterinis.egg-info/requires.txt
+src/asterinis.egg-info/top_level.txt
+src/asterinis/integrations/__init__.py
+src/asterinis/integrations/flair.py
+tests/test_nexus.py

asterinis-0.0.1/src/asterinis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

asterinis-0.0.1/src/asterinis.egg-info/requires.txt

@@ -0,0 +1,8 @@
+
+[dev]
+pytest>=8.0
+build>=1.2
+twine>=5.0
+
+[flair]
+flair>=0.15

asterinis-0.0.1/src/asterinis.egg-info/top_level.txt

@@ -0,0 +1 @@
+asterinis

asterinis-0.0.1/tests/test_nexus.py

@@ -0,0 +1,50 @@
+import pytest
+
+from asterinis import Nexus
+
+
+def test_info():
+    nexus = Nexus()
+
+    info = nexus.info()
+
+    assert info["name"] == "Asterinis"
+
+
+def test_rag_route():
+    nexus = Nexus()
+
+    result = nexus.process("Search documents about RAG.")
+
+    assert result.route == "rag"
+
+
+def test_nlp_route():
+    nexus = Nexus()
+
+    result = nexus.process("Analyze this entity using NLP.")
+
+    assert result.route == "nlp"
+
+
+def test_agent_route():
+    nexus = Nexus()
+
+    result = nexus.process("Use an agent workflow.")
+
+    assert result.route == "agent"
+
+
+def test_default_route():
+    nexus = Nexus()
+
+    result = nexus.process("Explain recursion.")
+
+    assert result.route == "llm"
+
+
+def test_empty_input():
+    nexus = Nexus()
+
+    with pytest.raises(ValueError):
+        nexus.process("")