cybnodes 0.1.0__tar.gz

cybnodes-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CybWu
+
+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.

cybnodes-0.1.0/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: cybnodes
+Version: 0.1.0
+Summary: Surround any LLM with verifiable capability networks (exact math, knowledge, web) and say each result back in its own voice.
+Author: CybWu
+License: MIT
+Project-URL: Homepage, https://cybnodes.pages.dev
+Project-URL: Repository, https://github.com/Alex-Lou/cybnodes
+Project-URL: Documentation, https://github.com/Alex-Lou/cybnodes#readme
+Keywords: llm,agent,graphrag,router,tool-use,rag,framework
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+
+# CybNodes
+
+**On n'alourdit pas le cerveau par force brute. On l'entoure de circuits structurés et vérifiables.**
+
+Une petite librairie Python qui entoure ton LLM de **réseaux de capacités** (calcul exact, savoir, recherche web), et qui redit chaque résultat **dans la voix de ton modèle**.
+
+**[cybnodes.pages.dev](https://cybnodes.pages.dev)** / [GitHub](https://github.com/Alex-Lou/cybnodes) / MIT
+
+</div>
+
+---
+
+## C'est quoi, concrètement ?
+
+CybNodes est une **librairie Python** (`pip install cybnodes`, puis `import cybnodes`). Pas une app, pas un service, pas un script à lancer : une **brique que tu branches autour de ton propre modèle**.
+
+L'idée : un LLM est génial pour *parler*, mauvais pour *garantir*. Il invente un calcul, hallucine une date, n'a pas l'actu. Plutôt que de grossir le modèle, CybNodes met devant lui des **réseaux**, chacun sait répondre de façon **exacte et vérifiable** à un type de question. Un **routeur** choisit le bon réseau ; un **tisseur** redit le résultat brut dans la voix de ton modèle pour garder son âme.
+
+> Conséquence : un petit modèle (qui tient sur ta machine) peut alimenter un système qui "pèse" bien plus lourd.
+
+---
+
+## Pourquoi
+
+| Sans CybNodes | Avec CybNodes |
+|---|---|
+| "47 × 38 ?" → le LLM tente, parfois faux | calcul **exact** (AST sûr), toujours juste |
+| "c'est quoi un X ?" → le LLM hallucine | réponse depuis **ton graphe de connaissances** |
+| "quoi de neuf sur Y ?" → données périmées | **recherche web** avec la source citée |
+| corriger un fait → ré-entraîner le modèle | éditer un **fichier**, zéro entraînement |
+
+Le savoir et les capacités vivent **hors du modèle**. Tu les corriges, tu les étends, sans toucher aux poids.
+
+---
+
+## Installation
+
+```bash
+pip install cybnodes          # bientôt sur PyPI
+# ou, depuis les sources :
+git clone https://github.com/Alex-Lou/cybnodes.git
+cd cybnodes && pip install -e .
+```
+
+Python ≥ 3.9. **Aucune dépendance obligatoire** (stdlib uniquement, le réseau web utilise `urllib`).
+
+---
+
+## Démarrage (60 secondes)
+
+```python
+from cybnodes import CybNodes, Persona
+from cybnodes.networks import CalculNetwork, SavoirNetwork
+
+# 1. Tu apportes TON modèle : n'importe quel callable (ollama, API, local…)
+def mon_llm(question, context):
+    return appelle_mon_modele(question, context)   # -> str
+
+# 2. Tu l'entoures de réseaux
+cyb = CybNodes(
+    conductor=mon_llm,
+    networks=[
+        CalculNetwork(),                              # calcul exact
+        SavoirNetwork(graph_path="mon_graphe.json"),  # GraphRAG sur tes triplets
+    ],
+    persona=Persona(name="Aria", templates={
+        "calcul": ["Voilà : {value} ✦", "{value}, et c'est exact !"],
+        "savoir": ["{value}"],
+    }),
+)
+
+# 3. Tu demandes
+cyb.ask("combien font 47 x 38 ?")   # → "Voilà : 47 x 38 = 1786 ✦"   (exact, jamais faux)
+cyb.ask("c'est quoi un chat ?")     # → depuis ton graphe, dans la voix d'Aria
+cyb.ask("écris-moi un haïku")       # → aucun réseau ne prend la main → ton modèle répond
+```
+
+C'est tout. Le routeur essaie les réseaux ; si aucun ne répond, ton modèle reprend la main, comme avant.
+
+---
+
+## L'architecture en 5 couches
+
+```
+        question
+           │
+   ┌───────▼────────┐
+   │   ROUTEUR      │  essaie les réseaux dans l'ordre (règles d'abord, fiable)
+   └───────┬────────┘
+     hit?  │  no hit
+   ┌───────▼──┐   └──────────────┐
+   │ RÉSEAU   │                  │
+   │ (calcul, │            ┌─────▼──────┐
+   │  savoir, │            │ CONDUCTEUR │  ton LLM (sa voix)
+   │  web…)   │            └─────┬──────┘
+   └───────┬──┘                  │
+   ┌───────▼────────┐            │
+   │   TISSEUR      │ redit dans │
+   │  + PERSONA     │ la voix    │
+   └───────┬────────┘            │
+           └──────────┬──────────┘
+                   réponse
+```
+
+| Couche | Classe | Rôle |
+|---|---|---|
+| **Conducteur** | `conductor=` (ton callable) | ton modèle, sa voix/personnalité |
+| **Réseaux** | `Network` | une capacité chacun, indépendants |
+| **Routeur** | `Router` | choisit le réseau ; un réseau qui plante n'écroule rien |
+| **Tisseur** | `Weaver` + `Persona` | redit le résultat brut dans la voix |
+| **Mémoire** | `Memory` | capte des faits sûrs sur l'utilisateur (backend pluggable) |
+
+---
+
+## Les réseaux livrés
+
+| Réseau | Ce qu'il fait | Vérifiable par |
+|---|---|---|
+| `CalculNetwork` | arithmétique exacte (`+ - × ÷ ^ %`, mots "fois / plus / puissance"…), AST sûr, **zéro `eval`** | le calcul lui-même |
+| `SavoirNetwork` | **GraphRAG** : répond depuis un graphe de triplets `sujet-relation-objet` | le nœud du graphe |
+| `WebNetwork` | recherche d'actu via l'API **Brave Search** (clé `BRAVE_API_KEY`), cite la source | l'URL renvoyée |
+
+Chaque réseau ne se déclenche que quand il est sûr de lui ; sinon il rend la main (renvoie `None`).
+
+---
+
+## Écrire ton propre réseau
+
+```python
+from cybnodes import Network, Result
+
+class MeteoNetwork(Network):
+    name = "meteo"
+
+    def match(self, question):
+        if "météo" not in question.lower():
+            return None                       # pas mon rayon → je rends la main
+        data = appel_api_meteo(...)           # un résultat VÉRIFIABLE (source réelle)
+        return Result(kind="meteo", text=f"Il fait {data}°", source="api-météo")
+
+cyb.add_network(MeteoNetwork())               # branché. C'est tout.
+```
+
+---
+
+## Quand l'utiliser (et quand non)
+
+**Utilise CybNodes quand** tu veux qu'un LLM réponde de façon **exacte / vérifiable / à jour** sur certains types de questions, tout en gardant **sa voix**, sans ré-entraîner.
+
+**Ne l'utilise pas** pour du pur génératif libre (écriture, brainstorming) : là, ton modèle seul suffit, CybNodes lui laisse simplement la main.
+
+---
+
+## Les 4 questions (les invariants)
+
+- **Où vit l'état ?** Personnalité → conducteur ; savoir → graphe (hors modèle) ; faits utilisateur → Mémoire.
+- **Où vit le feedback ?** Chaque réseau renvoie un résultat *vérifiable* (calcul exact, nœud du graphe, source web).
+- **Qu'est-ce qui casse si on retire X ?** Réseaux indépendants → on en retire un sans casser les autres.
+- **Timing / ordre ?** Routeur synchrone : 1 question → routeur → réseau(x) → tisseur → réponse.
+
+---
+
+## État du projet
+
+Ce qui marche aujourd'hui, testé (`python tests/test_cybnodes.py`) :
+
+- ✅ Cœur (routeur, tisseur/persona, mémoire, conducteur model-agnostic)
+- ✅ `CalculNetwork`, `SavoirNetwork` (GraphRAG), `WebNetwork` (Brave)
+
+Pistes ouvertes (design posé, pas encore livré, pas de promesse vide) :
+
+- Routeur d'intention par classifieur (plutôt qu'ordre fixe)
+- Réseaux code / langues / traduction
+- Backends de recherche additionnels
+
+---
+
+## Licence
+
+MIT, fais-en ce que tu veux.
+
+<div align="center">
+
+*Conçu par **CybWu**. Né autour d'une petite IA, pensé pour entourer n'importe quel modèle.*
+
+🐺
+
+</div>

cybnodes-0.1.0/README.md

@@ -0,0 +1,190 @@
+<div align="center">
+
+# CybNodes
+
+**On n'alourdit pas le cerveau par force brute. On l'entoure de circuits structurés et vérifiables.**
+
+Une petite librairie Python qui entoure ton LLM de **réseaux de capacités** (calcul exact, savoir, recherche web), et qui redit chaque résultat **dans la voix de ton modèle**.
+
+**[cybnodes.pages.dev](https://cybnodes.pages.dev)** / [GitHub](https://github.com/Alex-Lou/cybnodes) / MIT
+
+</div>
+
+---
+
+## C'est quoi, concrètement ?
+
+CybNodes est une **librairie Python** (`pip install cybnodes`, puis `import cybnodes`). Pas une app, pas un service, pas un script à lancer : une **brique que tu branches autour de ton propre modèle**.
+
+L'idée : un LLM est génial pour *parler*, mauvais pour *garantir*. Il invente un calcul, hallucine une date, n'a pas l'actu. Plutôt que de grossir le modèle, CybNodes met devant lui des **réseaux**, chacun sait répondre de façon **exacte et vérifiable** à un type de question. Un **routeur** choisit le bon réseau ; un **tisseur** redit le résultat brut dans la voix de ton modèle pour garder son âme.
+
+> Conséquence : un petit modèle (qui tient sur ta machine) peut alimenter un système qui "pèse" bien plus lourd.
+
+---
+
+## Pourquoi
+
+| Sans CybNodes | Avec CybNodes |
+|---|---|
+| "47 × 38 ?" → le LLM tente, parfois faux | calcul **exact** (AST sûr), toujours juste |
+| "c'est quoi un X ?" → le LLM hallucine | réponse depuis **ton graphe de connaissances** |
+| "quoi de neuf sur Y ?" → données périmées | **recherche web** avec la source citée |
+| corriger un fait → ré-entraîner le modèle | éditer un **fichier**, zéro entraînement |
+
+Le savoir et les capacités vivent **hors du modèle**. Tu les corriges, tu les étends, sans toucher aux poids.
+
+---
+
+## Installation
+
+```bash
+pip install cybnodes          # bientôt sur PyPI
+# ou, depuis les sources :
+git clone https://github.com/Alex-Lou/cybnodes.git
+cd cybnodes && pip install -e .
+```
+
+Python ≥ 3.9. **Aucune dépendance obligatoire** (stdlib uniquement, le réseau web utilise `urllib`).
+
+---
+
+## Démarrage (60 secondes)
+
+```python
+from cybnodes import CybNodes, Persona
+from cybnodes.networks import CalculNetwork, SavoirNetwork
+
+# 1. Tu apportes TON modèle : n'importe quel callable (ollama, API, local…)
+def mon_llm(question, context):
+    return appelle_mon_modele(question, context)   # -> str
+
+# 2. Tu l'entoures de réseaux
+cyb = CybNodes(
+    conductor=mon_llm,
+    networks=[
+        CalculNetwork(),                              # calcul exact
+        SavoirNetwork(graph_path="mon_graphe.json"),  # GraphRAG sur tes triplets
+    ],
+    persona=Persona(name="Aria", templates={
+        "calcul": ["Voilà : {value} ✦", "{value}, et c'est exact !"],
+        "savoir": ["{value}"],
+    }),
+)
+
+# 3. Tu demandes
+cyb.ask("combien font 47 x 38 ?")   # → "Voilà : 47 x 38 = 1786 ✦"   (exact, jamais faux)
+cyb.ask("c'est quoi un chat ?")     # → depuis ton graphe, dans la voix d'Aria
+cyb.ask("écris-moi un haïku")       # → aucun réseau ne prend la main → ton modèle répond
+```
+
+C'est tout. Le routeur essaie les réseaux ; si aucun ne répond, ton modèle reprend la main, comme avant.
+
+---
+
+## L'architecture en 5 couches
+
+```
+        question
+           │
+   ┌───────▼────────┐
+   │   ROUTEUR      │  essaie les réseaux dans l'ordre (règles d'abord, fiable)
+   └───────┬────────┘
+     hit?  │  no hit
+   ┌───────▼──┐   └──────────────┐
+   │ RÉSEAU   │                  │
+   │ (calcul, │            ┌─────▼──────┐
+   │  savoir, │            │ CONDUCTEUR │  ton LLM (sa voix)
+   │  web…)   │            └─────┬──────┘
+   └───────┬──┘                  │
+   ┌───────▼────────┐            │
+   │   TISSEUR      │ redit dans │
+   │  + PERSONA     │ la voix    │
+   └───────┬────────┘            │
+           └──────────┬──────────┘
+                   réponse
+```
+
+| Couche | Classe | Rôle |
+|---|---|---|
+| **Conducteur** | `conductor=` (ton callable) | ton modèle, sa voix/personnalité |
+| **Réseaux** | `Network` | une capacité chacun, indépendants |
+| **Routeur** | `Router` | choisit le réseau ; un réseau qui plante n'écroule rien |
+| **Tisseur** | `Weaver` + `Persona` | redit le résultat brut dans la voix |
+| **Mémoire** | `Memory` | capte des faits sûrs sur l'utilisateur (backend pluggable) |
+
+---
+
+## Les réseaux livrés
+
+| Réseau | Ce qu'il fait | Vérifiable par |
+|---|---|---|
+| `CalculNetwork` | arithmétique exacte (`+ - × ÷ ^ %`, mots "fois / plus / puissance"…), AST sûr, **zéro `eval`** | le calcul lui-même |
+| `SavoirNetwork` | **GraphRAG** : répond depuis un graphe de triplets `sujet-relation-objet` | le nœud du graphe |
+| `WebNetwork` | recherche d'actu via l'API **Brave Search** (clé `BRAVE_API_KEY`), cite la source | l'URL renvoyée |
+
+Chaque réseau ne se déclenche que quand il est sûr de lui ; sinon il rend la main (renvoie `None`).
+
+---
+
+## Écrire ton propre réseau
+
+```python
+from cybnodes import Network, Result
+
+class MeteoNetwork(Network):
+    name = "meteo"
+
+    def match(self, question):
+        if "météo" not in question.lower():
+            return None                       # pas mon rayon → je rends la main
+        data = appel_api_meteo(...)           # un résultat VÉRIFIABLE (source réelle)
+        return Result(kind="meteo", text=f"Il fait {data}°", source="api-météo")
+
+cyb.add_network(MeteoNetwork())               # branché. C'est tout.
+```
+
+---
+
+## Quand l'utiliser (et quand non)
+
+**Utilise CybNodes quand** tu veux qu'un LLM réponde de façon **exacte / vérifiable / à jour** sur certains types de questions, tout en gardant **sa voix**, sans ré-entraîner.
+
+**Ne l'utilise pas** pour du pur génératif libre (écriture, brainstorming) : là, ton modèle seul suffit, CybNodes lui laisse simplement la main.
+
+---
+
+## Les 4 questions (les invariants)
+
+- **Où vit l'état ?** Personnalité → conducteur ; savoir → graphe (hors modèle) ; faits utilisateur → Mémoire.
+- **Où vit le feedback ?** Chaque réseau renvoie un résultat *vérifiable* (calcul exact, nœud du graphe, source web).
+- **Qu'est-ce qui casse si on retire X ?** Réseaux indépendants → on en retire un sans casser les autres.
+- **Timing / ordre ?** Routeur synchrone : 1 question → routeur → réseau(x) → tisseur → réponse.
+
+---
+
+## État du projet
+
+Ce qui marche aujourd'hui, testé (`python tests/test_cybnodes.py`) :
+
+- ✅ Cœur (routeur, tisseur/persona, mémoire, conducteur model-agnostic)
+- ✅ `CalculNetwork`, `SavoirNetwork` (GraphRAG), `WebNetwork` (Brave)
+
+Pistes ouvertes (design posé, pas encore livré, pas de promesse vide) :
+
+- Routeur d'intention par classifieur (plutôt qu'ordre fixe)
+- Réseaux code / langues / traduction
+- Backends de recherche additionnels
+
+---
+
+## Licence
+
+MIT, fais-en ce que tu veux.
+
+<div align="center">
+
+*Conçu par **CybWu**. Né autour d'une petite IA, pensé pour entourer n'importe quel modèle.*
+
+🐺
+
+</div>

cybnodes-0.1.0/cybnodes/__init__.py

@@ -0,0 +1,25 @@
+"""CybNodes : un petit conducteur a personnalite entoure de reseaux de nodes par capacite.
+
+Principe (framework de CybWu) : on n'alourdit pas le cerveau par force brute ; on l'entoure
+de circuits structures et verifiables. Un petit modele peut alors alimenter un systeme
+qui "pese" bien plus lourd.
+
+    from cybnodes import CybNodes, Persona
+    from cybnodes.networks import CalculNetwork, SavoirNetwork
+
+    cyb = CybNodes(
+        conductor=mon_llm,                       # callable(question, context) -> str
+        networks=[CalculNetwork(), SavoirNetwork(graph_path="graphe.json")],
+        persona=Persona(name="N3", templates={"calcul": ["Hop, {value} !"]}),
+    )
+    cyb.ask("combien font 7 x 8 ?")   # -> reponse EXACTE, tissee dans la voix
+"""
+from .core import CybNodes
+from .memory import Memory
+from .network import Network
+from .result import Result
+from .router import Router
+from .weaver import Persona, Weaver
+
+__all__ = ["CybNodes", "Network", "Result", "Router", "Weaver", "Persona", "Memory"]
+__version__ = "0.1.0"

cybnodes-0.1.0/cybnodes/core.py

@@ -0,0 +1,56 @@
+"""CybNodes : le conducteur a personnalite + ses reseaux.
+
+    ask(question) :
+      1. (option) capte les faits surs -> Memoire
+      2. ROUTEUR : un reseau prend-il la main ? -> TISSEUR (reponse exacte, dans la voix)
+      3. sinon -> CONDUCTEUR (TON modele) avec le contexte memoire
+
+Model-agnostic : tu apportes ton LLM via `conductor=callable(question, context) -> str`.
+Le squelette (routeur/reseaux/tisseur/memoire) se transfere tel quel d'un modele a l'autre.
+"""
+from __future__ import annotations
+
+from typing import Callable, List, Optional
+
+from .memory import Memory
+from .network import Network
+from .result import Result
+from .router import Router
+from .weaver import Persona, Weaver
+
+
+class CybNodes:
+    def __init__(self,
+                 conductor: Optional[Callable[[str, Optional[str]], str]] = None,
+                 networks: Optional[List[Network]] = None,
+                 persona: Optional[Persona] = None,
+                 weaver: Optional[Weaver] = None,
+                 memory: Optional[Memory] = None):
+        self.router = Router(networks)
+        self.weaver = weaver or Weaver(persona)
+        self.memory = memory
+        self.conductor = conductor
+
+    def add_network(self, network: Network) -> "CybNodes":
+        self.router.add(network)
+        return self
+
+    def route_only(self, question: str) -> Optional[Result]:
+        """Debug/test : le Result brut du routeur, sans tissage ni modele."""
+        return self.router.route((question or "").strip())
+
+    def ask(self, question: str, context: Optional[str] = None) -> Optional[str]:
+        q = (question or "").strip()
+        if not q:
+            return None
+        if self.memory:
+            self.memory.capture(q)
+        hit = self.router.route(q)
+        if hit is not None:
+            return self.weaver.weave(hit)
+        if self.conductor is not None:
+            if context is None and self.memory:
+                facts = self.memory.recall(q)
+                context = " ".join(facts) if facts else None
+            return self.conductor(q, context)
+        return None

cybnodes-0.1.0/cybnodes/memory.py

@@ -0,0 +1,43 @@
+"""Memory : capte des faits SURS sur l'utilisateur et les rappelle.
+
+Backend pluggable : par defaut en RAM (un dict). Passe n'importe quel objet dict-like
+PERSISTANT (Modal Dict, Redis, sqlite-dict...) pour survivre aux redemarrages.
+Les "capturers" sont des callables `(message) -> list[str]` : a toi de fournir des
+patterns SURS (zero pollution). On n'invente jamais un fait, on ne fait que capter.
+"""
+from __future__ import annotations
+
+from typing import Callable, List, Optional
+
+
+class Memory:
+    def __init__(self, store: Optional[dict] = None,
+                 capturers: Optional[List[Callable[[str], List[str]]]] = None,
+                 max_facts: int = 40):
+        self.store = store if store is not None else {}
+        self.capturers: List[Callable[[str], List[str]]] = list(capturers or [])
+        self.max_facts = max_facts
+
+    def facts(self) -> List[str]:
+        return list(self.store.get("facts", []))
+
+    def add_capturer(self, capturer: Callable[[str], List[str]]) -> "Memory":
+        self.capturers.append(capturer)
+        return self
+
+    def capture(self, message: str) -> List[str]:
+        facts = self.facts()
+        for capturer in self.capturers:
+            try:
+                found = capturer(message) or []
+            except Exception:
+                found = []
+            for fact in found:
+                if fact and fact not in facts:
+                    facts.append(fact)
+        facts = facts[-self.max_facts:]
+        self.store["facts"] = facts
+        return facts
+
+    def recall(self, question: str = "") -> List[str]:
+        return self.facts()

cybnodes-0.1.0/cybnodes/network.py

@@ -0,0 +1,25 @@
+"""Network : la brique de capacite. On en branche autant qu'on veut, elles sont independantes."""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from .result import Result
+
+
+class Network(ABC):
+    """Un reseau de capacite (calcul, savoir, web, code...).
+
+    Contrat : `match(question)` renvoie un `Result` si le reseau SAIT repondre de maniere
+    sure/verifiable, sinon `None` (et la main passe au reseau suivant, puis au modele).
+    Un reseau est sans etat partage : on peut l'ajouter ou le retirer sans casser les autres.
+    """
+
+    name: str = "network"
+
+    @abstractmethod
+    def match(self, question: str) -> Optional[Result]:
+        ...
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return "<Network %s>" % self.name

cybnodes-0.1.0/cybnodes/networks/__init__.py

@@ -0,0 +1,6 @@
+"""Reseaux de capacite livres avec CybNodes. Ecris les tiens en heritant de `cybnodes.Network`."""
+from .calcul import CalculNetwork
+from .savoir import SavoirNetwork
+from .web import WebNetwork
+
+__all__ = ["CalculNetwork", "SavoirNetwork", "WebNetwork"]

cybnodes-0.1.0/cybnodes/networks/calcul.py

@@ -0,0 +1,83 @@
+"""Reseau CALCUL : arithmetique EXACTE.
+
+Ce qu'un cerveau de LLM ne fait pas de maniere sure. On detecte une expression
+(chiffres + operateurs, ou mots francais "fois/plus/divise par/puissance...") seulement
+si elle relie au moins deux nombres, on l'evalue via un AST securise (aucun eval()),
+et on renvoie un Result que le Tisseur redira dans la voix du conducteur.
+"""
+from __future__ import annotations
+
+import ast
+import operator
+import re
+from typing import Optional
+
+from ..network import Network
+from ..result import Result
+
+_OPS = {
+    ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
+    ast.Div: operator.truediv, ast.Pow: operator.pow, ast.Mod: operator.mod,
+    ast.USub: operator.neg, ast.UAdd: operator.pos,
+}
+
+# mots -> operateurs (appliques seulement si entre des nombres, cf _EXPR)
+_WORD_OPS = [
+    (re.compile(r"\bmultipli[ée]+ par\b", re.I), " * "),
+    (re.compile(r"\bdivis[ée]+ par\b", re.I), " / "),
+    (re.compile(r"\bpuissance\b", re.I), " ** "),
+    (re.compile(r"\bmodulo\b", re.I), " % "),
+    (re.compile(r"\bplus\b", re.I), " + "),
+    (re.compile(r"\bmoins\b", re.I), " - "),
+    (re.compile(r"\bfois\b", re.I), " * "),
+]
+
+# une vraie expression : >= deux nombres relies par des operateurs (** inclus)
+_EXPR = re.compile(
+    r"[-+]?\d[\d ]*(?:[.,]\d+)?(?:\s*(?:\*\*|[-+*/x×÷^%])\s*[-+]?\d[\d ]*(?:[.,]\d+)?)+"
+)
+
+
+def _safe_eval(node):
+    if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+        return node.value
+    if isinstance(node, ast.BinOp) and type(node.op) in _OPS:
+        return _OPS[type(node.op)](_safe_eval(node.left), _safe_eval(node.right))
+    if isinstance(node, ast.UnaryOp) and type(node.op) in _OPS:
+        return _OPS[type(node.op)](_safe_eval(node.operand))
+    raise ValueError("expression non supportee")
+
+
+def _clean(raw: str) -> str:
+    # raw vient deja de _EXPR (chiffres + operateurs) : le 'x' y est forcement multiplicatif.
+    s = raw.replace("×", "*").replace("x", "*").replace("÷", "/").replace("^", "**")
+    return s.replace(",", ".").replace(" ", "")
+
+
+class CalculNetwork(Network):
+    name = "calcul"
+
+    def match(self, question: str) -> Optional[Result]:
+        work = question or ""
+        for rx, op in _WORD_OPS:
+            work = rx.sub(op, work)
+        m = _EXPR.search(work)
+        if not m:
+            return None
+        expr = _clean(m.group(0))
+        if not re.search(r"\*\*|[-+*/%]", expr):  # garde-fou : un vrai operateur
+            return None
+        try:
+            value = _safe_eval(ast.parse(expr, mode="eval").body)
+        except Exception:
+            return None
+        if isinstance(value, float):
+            value = int(value) if value.is_integer() else round(value, 4)
+        pretty = re.sub(r"\s*\*\*\s*", " ^ ", m.group(0).strip())
+        pretty = re.sub(r"\s*\*\s*", " x ", pretty)
+        return Result(
+            kind="calcul",
+            text="%s = %s" % (pretty, value),
+            data={"expr": pretty, "value": value},
+            source="calcul exact (AST)",
+        )

cybnodes-0.1.0/cybnodes/networks/savoir.py

@@ -0,0 +1,92 @@
+"""Reseau SAVOIR (GraphRAG) : repond depuis un graphe de connaissances (triplets sujet-relation-objet).
+
+Le savoir vit HORS du modele -> on le corrige/etend en editant le graphe, sans re-entrainer.
+Le reseau ne se declenche que sur une INTENTION de savoir (c'est quoi / qu'est-ce que / a quoi
+ca sert...) ET si une entite connue (sujet d'au moins un triplet) apparait dans la question.
+Il compose alors une phrase a partir des triplets de cette entite, que le Tisseur revoix.
+
+Graphe attendu : {"triples": [{"s": "...", "r": "...", "o": "..."}, ...]} ou directement la liste.
+"""
+from __future__ import annotations
+
+import json
+import re
+import unicodedata
+from typing import List, Optional
+
+from ..network import Network
+from ..result import Result
+
+
+def _deacc(s: str) -> str:
+    return "".join(
+        c for c in unicodedata.normalize("NFD", (s or "").lower())
+        if unicodedata.category(c) != "Mn"
+    )
+
+
+# verbalisation des relations -> phrase lisible (vocabulaire controle, extensible)
+_REL_VERB = {
+    "est_un": "est un", "est_une": "est une", "partie_de": "fait partie de",
+    "sert_a": "sert a", "fait": "fait", "mange": "mange", "vit_dans": "vit dans",
+    "a": "a", "a_besoin_de": "a besoin de", "aime": "aime", "cause": "cause",
+    "devient": "devient", "donne": "donne", "contraire_de": "est le contraire de",
+    "plus_grand_que": "est plus grand que", "vient_de": "vient de",
+    "vient_dans": "se trouve dans", "vient_apres": "vient apres",
+}
+
+_INTENT = re.compile(
+    r"c'?est quoi|qu'?est[- ]?ce|c'?est qui|\bquel(?:le|s|les)?\b|connais[- ]?tu|sais[- ]?tu"
+    r"|parle[- ]?moi|raconte|\bdefinition\b|decri|a quoi (?:ca |ca |)sert|ca sert a quoi",
+    re.I,
+)
+
+
+class SavoirNetwork(Network):
+    name = "savoir"
+
+    def __init__(self, triples: Optional[List[dict]] = None,
+                 graph_path: Optional[str] = None,
+                 min_entity_len: int = 3,
+                 max_clauses: int = 4):
+        if graph_path:
+            with open(graph_path, encoding="utf-8") as fh:
+                data = json.load(fh)
+            triples = data.get("triples", []) if isinstance(data, dict) else data
+        self.triples: List[dict] = list(triples or [])
+        self.min_entity_len = min_entity_len
+        self.max_clauses = max_clauses
+        self._by_subject: dict = {}
+        for t in self.triples:
+            s = t.get("s")
+            if s:
+                self._by_subject.setdefault(_deacc(s), []).append(t)
+
+    def _find_entity(self, question: str) -> Optional[str]:
+        words = [w for w in re.split(r"[^a-z0-9]+", _deacc(question)) if w]
+        cands = [w for w in words if len(w) >= self.min_entity_len and w in self._by_subject]
+        return max(cands, key=len) if cands else None  # le mot connu le plus long
+
+    def match(self, question: str) -> Optional[Result]:
+        q = question or ""
+        if not _INTENT.search(_deacc(q)):
+            return None
+        ent = self._find_entity(q)
+        if not ent:
+            return None
+        facts = self._by_subject.get(ent, [])
+        if not facts:
+            return None
+        label = facts[0]["s"]
+        clauses = []
+        for t in facts[:self.max_clauses]:
+            verb = _REL_VERB.get(t["r"], t["r"].replace("_", " "))
+            clauses.append("%s %s" % (verb, t["o"]))
+        text = "%s %s." % (label.capitalize(), ", ".join(clauses))
+        return Result(
+            kind="savoir",
+            text=text,
+            data={"entity": label,
+                  "facts": [[t["s"], t["r"], t["o"]] for t in facts[:self.max_clauses]]},
+            source="graphe de connaissances",
+        )

cybnodes-0.1.0/cybnodes/networks/web.py

@@ -0,0 +1,72 @@
+"""Reseau WEB : recherche d'actualite / faits externes via l'API Brave Search (tier gratuit).
+
+Se declenche seulement sur une INTENTION de recherche (cherche / actualite / recent /
+aujourd'hui / en ligne...). Honnete : la reponse dit "j'ai cherche" et porte la SOURCE (URL).
+Degrade proprement : sans cle API, `match` renvoie None -> le modele repond comme avant.
+
+Cle : variable d'env `BRAVE_API_KEY` (https://brave.com/search/api/ , tier gratuit). Aucune
+dependance externe (urllib stdlib). `fetch` est injectable -> testable sans reseau ni cle.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import urllib.parse
+import urllib.request
+from typing import Callable, Optional
+
+from ..network import Network
+from ..result import Result
+
+_INTENT = re.compile(
+    r"\bcherche?\b|\bactualit|\bnews\b|quoi de neuf|r[eé]cent|derni[eè]re?s? nouvelles"
+    r"|en ce moment|aujourd'?hui|ce qui se passe|\bgoogle\b|sur internet|en ligne",
+    re.I,
+)
+
+
+class WebNetwork(Network):
+    name = "web"
+    ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
+
+    def __init__(self, api_key: Optional[str] = None, env_var: str = "BRAVE_API_KEY",
+                 max_results: int = 3, timeout: int = 8,
+                 fetch: Optional[Callable[[str], dict]] = None):
+        self.api_key = api_key or os.environ.get(env_var)
+        self.max_results = max_results
+        self.timeout = timeout
+        self._fetch = fetch or self._http  # injectable pour les tests
+
+    def _http(self, query: str) -> dict:
+        url = self.ENDPOINT + "?" + urllib.parse.urlencode({"q": query, "count": self.max_results})
+        req = urllib.request.Request(url, headers={
+            "X-Subscription-Token": self.api_key or "",
+            "Accept": "application/json",
+        })
+        with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+            return json.load(resp)
+
+    def match(self, question: str) -> Optional[Result]:
+        q = (question or "").strip()
+        if not q or not _INTENT.search(q):
+            return None
+        if not self.api_key:
+            return None  # pas de cle -> on laisse le modele repondre (pas de fausse promesse)
+        try:
+            data = self._fetch(q)
+        except Exception:
+            return None
+        results = ((data or {}).get("web", {}) or {}).get("results", [])[:self.max_results]
+        if not results:
+            return None
+        top = results[0]
+        snippet = re.sub(r"<[^>]+>", "", top.get("description", "") or "").strip()
+        text = "J'ai cherche, et voila ce que j'ai trouve : %s" % (snippet or top.get("title", ""))
+        return Result(
+            kind="web",
+            text=text,
+            data={"query": q, "title": top.get("title", ""), "snippet": snippet,
+                  "results": [{"title": r.get("title"), "url": r.get("url")} for r in results]},
+            source=top.get("url"),
+        )

cybnodes-0.1.0/cybnodes/result.py

@@ -0,0 +1,22 @@
+"""Result : ce qu'un reseau renvoie quand il prend la main."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class Result:
+    """Resultat brut d'un reseau, avant tissage.
+
+    - kind     : type de reseau ("calcul", "savoir", "web"...) -> choisit le gabarit du Tisseur.
+    - text     : reponse lisible (fallback si la persona n'a pas de gabarit pour ce kind).
+    - data     : donnees structurees (champs nommes reutilisables par les gabarits).
+    - source   : tracabilite -> rend la reponse VERIFIABLE (calcul exact, node du graphe, URL...).
+    - confidence : 0..1, pour qu'un routeur avance puisse arbitrer plus tard.
+    """
+    kind: str
+    text: str
+    data: dict = field(default_factory=dict)
+    source: Optional[str] = None
+    confidence: float = 1.0

cybnodes-0.1.0/cybnodes/router.py

@@ -0,0 +1,30 @@
+"""Router : lit l'intention via les reseaux, choisit le premier qui prend la main.
+
+Regles d'abord (fiable), modele ensuite. Un reseau qui leve une exception est ignore
+(fail-safe) : il ne doit jamais faire tomber tout le circuit.
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from .network import Network
+from .result import Result
+
+
+class Router:
+    def __init__(self, networks: Optional[List[Network]] = None):
+        self.networks: List[Network] = list(networks or [])
+
+    def add(self, network: Network) -> "Router":
+        self.networks.append(network)
+        return self
+
+    def route(self, question: str) -> Optional[Result]:
+        for net in self.networks:
+            try:
+                result = net.match(question)
+            except Exception:
+                result = None  # un reseau fragile ne casse jamais le circuit
+            if result is not None:
+                return result
+        return None

cybnodes-0.1.0/cybnodes/weaver.py

@@ -0,0 +1,42 @@
+"""Weaver (le Tisseur) : reprend le Result brut d'un reseau et le redit dans la VOIX de la persona.
+
+C'est ce qui garde l'ame du conducteur quand c'est un outil (et pas le modele) qui repond.
+La persona porte des gabarits par `kind` ; `{value}` = la reponse brute, plus tous les
+champs de `result.data`. Sans gabarit pour ce kind, on renvoie `result.text` tel quel.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from .result import Result
+
+
+@dataclass
+class Persona:
+    name: str = "CybNodes"
+    templates: Dict[str, List[str]] = field(default_factory=dict)
+
+    def template_for(self, kind: str) -> Optional[List[str]]:
+        return self.templates.get(kind)
+
+
+class Weaver:
+    def __init__(self, persona: Optional[Persona] = None):
+        self.persona = persona or Persona()
+
+    def weave(self, result: Result) -> str:
+        templates = self.persona.template_for(result.kind)
+        if not templates:
+            return result.text
+        # choix deterministe (pas de hasard -> testable/reproductible) base sur le contenu
+        seed = str(result.data.get("expr") or result.data.get("entity") or result.text)
+        tpl = templates[sum(ord(c) for c in seed) % len(templates)]
+        # {value} = TOUJOURS la reponse brute lisible (reserve, mis apres les data
+        # pour qu'une cle data nommee "value" ne l'ecrase pas). {expr}, {entity}... = data.
+        fields = dict(result.data)
+        fields["value"] = result.text
+        try:
+            return tpl.format(**fields)
+        except (KeyError, IndexError, ValueError):
+            return tpl.replace("{value}", result.text)

cybnodes-0.1.0/cybnodes.egg-info/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: cybnodes
+Version: 0.1.0
+Summary: Surround any LLM with verifiable capability networks (exact math, knowledge, web) and say each result back in its own voice.
+Author: CybWu
+License: MIT
+Project-URL: Homepage, https://cybnodes.pages.dev
+Project-URL: Repository, https://github.com/Alex-Lou/cybnodes
+Project-URL: Documentation, https://github.com/Alex-Lou/cybnodes#readme
+Keywords: llm,agent,graphrag,router,tool-use,rag,framework
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+
+# CybNodes
+
+**On n'alourdit pas le cerveau par force brute. On l'entoure de circuits structurés et vérifiables.**
+
+Une petite librairie Python qui entoure ton LLM de **réseaux de capacités** (calcul exact, savoir, recherche web), et qui redit chaque résultat **dans la voix de ton modèle**.
+
+**[cybnodes.pages.dev](https://cybnodes.pages.dev)** / [GitHub](https://github.com/Alex-Lou/cybnodes) / MIT
+
+</div>
+
+---
+
+## C'est quoi, concrètement ?
+
+CybNodes est une **librairie Python** (`pip install cybnodes`, puis `import cybnodes`). Pas une app, pas un service, pas un script à lancer : une **brique que tu branches autour de ton propre modèle**.
+
+L'idée : un LLM est génial pour *parler*, mauvais pour *garantir*. Il invente un calcul, hallucine une date, n'a pas l'actu. Plutôt que de grossir le modèle, CybNodes met devant lui des **réseaux**, chacun sait répondre de façon **exacte et vérifiable** à un type de question. Un **routeur** choisit le bon réseau ; un **tisseur** redit le résultat brut dans la voix de ton modèle pour garder son âme.
+
+> Conséquence : un petit modèle (qui tient sur ta machine) peut alimenter un système qui "pèse" bien plus lourd.
+
+---
+
+## Pourquoi
+
+| Sans CybNodes | Avec CybNodes |
+|---|---|
+| "47 × 38 ?" → le LLM tente, parfois faux | calcul **exact** (AST sûr), toujours juste |
+| "c'est quoi un X ?" → le LLM hallucine | réponse depuis **ton graphe de connaissances** |
+| "quoi de neuf sur Y ?" → données périmées | **recherche web** avec la source citée |
+| corriger un fait → ré-entraîner le modèle | éditer un **fichier**, zéro entraînement |
+
+Le savoir et les capacités vivent **hors du modèle**. Tu les corriges, tu les étends, sans toucher aux poids.
+
+---
+
+## Installation
+
+```bash
+pip install cybnodes          # bientôt sur PyPI
+# ou, depuis les sources :
+git clone https://github.com/Alex-Lou/cybnodes.git
+cd cybnodes && pip install -e .
+```
+
+Python ≥ 3.9. **Aucune dépendance obligatoire** (stdlib uniquement, le réseau web utilise `urllib`).
+
+---
+
+## Démarrage (60 secondes)
+
+```python
+from cybnodes import CybNodes, Persona
+from cybnodes.networks import CalculNetwork, SavoirNetwork
+
+# 1. Tu apportes TON modèle : n'importe quel callable (ollama, API, local…)
+def mon_llm(question, context):
+    return appelle_mon_modele(question, context)   # -> str
+
+# 2. Tu l'entoures de réseaux
+cyb = CybNodes(
+    conductor=mon_llm,
+    networks=[
+        CalculNetwork(),                              # calcul exact
+        SavoirNetwork(graph_path="mon_graphe.json"),  # GraphRAG sur tes triplets
+    ],
+    persona=Persona(name="Aria", templates={
+        "calcul": ["Voilà : {value} ✦", "{value}, et c'est exact !"],
+        "savoir": ["{value}"],
+    }),
+)
+
+# 3. Tu demandes
+cyb.ask("combien font 47 x 38 ?")   # → "Voilà : 47 x 38 = 1786 ✦"   (exact, jamais faux)
+cyb.ask("c'est quoi un chat ?")     # → depuis ton graphe, dans la voix d'Aria
+cyb.ask("écris-moi un haïku")       # → aucun réseau ne prend la main → ton modèle répond
+```
+
+C'est tout. Le routeur essaie les réseaux ; si aucun ne répond, ton modèle reprend la main, comme avant.
+
+---
+
+## L'architecture en 5 couches
+
+```
+        question
+           │
+   ┌───────▼────────┐
+   │   ROUTEUR      │  essaie les réseaux dans l'ordre (règles d'abord, fiable)
+   └───────┬────────┘
+     hit?  │  no hit
+   ┌───────▼──┐   └──────────────┐
+   │ RÉSEAU   │                  │
+   │ (calcul, │            ┌─────▼──────┐
+   │  savoir, │            │ CONDUCTEUR │  ton LLM (sa voix)
+   │  web…)   │            └─────┬──────┘
+   └───────┬──┘                  │
+   ┌───────▼────────┐            │
+   │   TISSEUR      │ redit dans │
+   │  + PERSONA     │ la voix    │
+   └───────┬────────┘            │
+           └──────────┬──────────┘
+                   réponse
+```
+
+| Couche | Classe | Rôle |
+|---|---|---|
+| **Conducteur** | `conductor=` (ton callable) | ton modèle, sa voix/personnalité |
+| **Réseaux** | `Network` | une capacité chacun, indépendants |
+| **Routeur** | `Router` | choisit le réseau ; un réseau qui plante n'écroule rien |
+| **Tisseur** | `Weaver` + `Persona` | redit le résultat brut dans la voix |
+| **Mémoire** | `Memory` | capte des faits sûrs sur l'utilisateur (backend pluggable) |
+
+---
+
+## Les réseaux livrés
+
+| Réseau | Ce qu'il fait | Vérifiable par |
+|---|---|---|
+| `CalculNetwork` | arithmétique exacte (`+ - × ÷ ^ %`, mots "fois / plus / puissance"…), AST sûr, **zéro `eval`** | le calcul lui-même |
+| `SavoirNetwork` | **GraphRAG** : répond depuis un graphe de triplets `sujet-relation-objet` | le nœud du graphe |
+| `WebNetwork` | recherche d'actu via l'API **Brave Search** (clé `BRAVE_API_KEY`), cite la source | l'URL renvoyée |
+
+Chaque réseau ne se déclenche que quand il est sûr de lui ; sinon il rend la main (renvoie `None`).
+
+---
+
+## Écrire ton propre réseau
+
+```python
+from cybnodes import Network, Result
+
+class MeteoNetwork(Network):
+    name = "meteo"
+
+    def match(self, question):
+        if "météo" not in question.lower():
+            return None                       # pas mon rayon → je rends la main
+        data = appel_api_meteo(...)           # un résultat VÉRIFIABLE (source réelle)
+        return Result(kind="meteo", text=f"Il fait {data}°", source="api-météo")
+
+cyb.add_network(MeteoNetwork())               # branché. C'est tout.
+```
+
+---
+
+## Quand l'utiliser (et quand non)
+
+**Utilise CybNodes quand** tu veux qu'un LLM réponde de façon **exacte / vérifiable / à jour** sur certains types de questions, tout en gardant **sa voix**, sans ré-entraîner.
+
+**Ne l'utilise pas** pour du pur génératif libre (écriture, brainstorming) : là, ton modèle seul suffit, CybNodes lui laisse simplement la main.
+
+---
+
+## Les 4 questions (les invariants)
+
+- **Où vit l'état ?** Personnalité → conducteur ; savoir → graphe (hors modèle) ; faits utilisateur → Mémoire.
+- **Où vit le feedback ?** Chaque réseau renvoie un résultat *vérifiable* (calcul exact, nœud du graphe, source web).
+- **Qu'est-ce qui casse si on retire X ?** Réseaux indépendants → on en retire un sans casser les autres.
+- **Timing / ordre ?** Routeur synchrone : 1 question → routeur → réseau(x) → tisseur → réponse.
+
+---
+
+## État du projet
+
+Ce qui marche aujourd'hui, testé (`python tests/test_cybnodes.py`) :
+
+- ✅ Cœur (routeur, tisseur/persona, mémoire, conducteur model-agnostic)
+- ✅ `CalculNetwork`, `SavoirNetwork` (GraphRAG), `WebNetwork` (Brave)
+
+Pistes ouvertes (design posé, pas encore livré, pas de promesse vide) :
+
+- Routeur d'intention par classifieur (plutôt qu'ordre fixe)
+- Réseaux code / langues / traduction
+- Backends de recherche additionnels
+
+---
+
+## Licence
+
+MIT, fais-en ce que tu veux.
+
+<div align="center">
+
+*Conçu par **CybWu**. Né autour d'une petite IA, pensé pour entourer n'importe quel modèle.*
+
+🐺
+
+</div>

cybnodes-0.1.0/cybnodes.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+cybnodes/__init__.py
+cybnodes/core.py
+cybnodes/memory.py
+cybnodes/network.py
+cybnodes/result.py
+cybnodes/router.py
+cybnodes/weaver.py
+cybnodes.egg-info/PKG-INFO
+cybnodes.egg-info/SOURCES.txt
+cybnodes.egg-info/dependency_links.txt
+cybnodes.egg-info/requires.txt
+cybnodes.egg-info/top_level.txt
+cybnodes/networks/__init__.py
+cybnodes/networks/calcul.py
+cybnodes/networks/savoir.py
+cybnodes/networks/web.py
+tests/test_cybnodes.py

cybnodes-0.1.0/cybnodes.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cybnodes-0.1.0/cybnodes.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest

cybnodes-0.1.0/cybnodes.egg-info/top_level.txt

@@ -0,0 +1 @@
+cybnodes

cybnodes-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cybnodes"
+version = "0.1.0"
+description = "Surround any LLM with verifiable capability networks (exact math, knowledge, web) and say each result back in its own voice."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "CybWu" }]
+keywords = ["llm", "agent", "graphrag", "router", "tool-use", "rag", "framework"]
+dependencies = []
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "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",
+]
+
+[project.urls]
+Homepage = "https://cybnodes.pages.dev"
+Repository = "https://github.com/Alex-Lou/cybnodes"
+Documentation = "https://github.com/Alex-Lou/cybnodes#readme"
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[tool.setuptools.packages.find]
+include = ["cybnodes*"]

cybnodes-0.1.0/setup.cfg

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

cybnodes-0.1.0/tests/test_cybnodes.py

@@ -0,0 +1,92 @@
+"""Tests CybNodes : calcul, savoir (GraphRAG), tissage, memoire, fallback conducteur.
+
+Lancement : depuis le dossier cybnodes/  ->  python tests/test_cybnodes.py
+(ou `pytest` si installe). Self-contained : ajoute le package au path.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from cybnodes import CybNodes, Memory, Persona  # noqa: E402
+from cybnodes.networks import CalculNetwork, SavoirNetwork, WebNetwork  # noqa: E402
+
+GRAPH = [
+    {"s": "chat", "r": "est_un", "o": "animal"},
+    {"s": "chat", "r": "fait", "o": "miaou"},
+    {"s": "chat", "r": "mange", "o": "des croquettes"},
+    {"s": "soleil", "r": "est_un", "o": "etoile"},
+]
+
+
+def test_calcul_exact():
+    net = CalculNetwork()
+    assert net.match("combien font 7 x 8 ?").data["value"] == 56
+    assert net.match("100 - 37").data["value"] == 63
+    assert net.match("245 multiplie par 6").data["value"] == 1470
+    assert net.match("10 divise par 4").data["value"] == 2.5
+    assert net.match("2 puissance 10").data["value"] == 1024   # 'puissance' repare
+    assert net.match("j'ai 30 ans") is None                    # un seul nombre -> pas un calcul
+    assert net.match("j'aime les chats") is None
+
+
+def test_savoir_graphrag():
+    net = SavoirNetwork(triples=GRAPH)
+    r = net.match("c'est quoi un chat ?")
+    assert r is not None and r.data["entity"] == "chat"
+    assert "animal" in r.text and "miaou" in r.text
+    assert net.match("j'ai vu un chat") is None        # pas d'intention de savoir -> None
+    assert net.match("c'est quoi un dragon ?") is None  # entite inconnue -> None
+
+
+def test_routing_and_voice():
+    cyb = CybNodes(
+        conductor=lambda q, ctx: "MODELE: " + q,
+        networks=[CalculNetwork(), SavoirNetwork(triples=GRAPH)],
+        persona=Persona(templates={"calcul": ["Hop, {value} !"]}),
+    )
+    assert cyb.ask("3 + 4") == "Hop, 3 + 4 = 7 !"          # calcul -> tisse
+    assert "animal" in cyb.ask("c'est quoi un chat ?")     # savoir -> brut (pas de gabarit)
+    assert cyb.ask("bonjour ca va ?") == "MODELE: bonjour ca va ?"  # fallback conducteur
+
+
+def test_memory_capture():
+    def capt(msg):
+        return ["L'utilisateur s'appelle Marie"] if "je suis marie" in msg.lower() else []
+
+    captured = {}
+    cyb = CybNodes(
+        conductor=lambda q, ctx: "ctx=%s" % ctx,
+        memory=Memory(capturers=[capt]),
+    )
+    cyb.ask("Je suis Marie")
+    assert "Marie" in cyb.ask("tu te souviens ?")   # le fait capte est injecte en contexte
+
+
+def test_web_search():
+    fake = {"web": {"results": [
+        {"title": "Mars", "description": "La planete <b>Mars</b> est rouge.", "url": "http://ex/mars"},
+    ]}}
+    net = WebNetwork(api_key="FAKE", fetch=lambda q: fake)
+    r = net.match("cherche des infos sur Mars")
+    assert r is not None and "Mars est rouge" in r.text and r.source == "http://ex/mars"
+    assert net.match("je t'aime bien") is None          # pas d'intention de recherche -> None
+    # sans cle : degrade proprement (le modele repondra)
+    assert WebNetwork(api_key=None, fetch=lambda q: fake).match("cherche Mars") is None
+
+
+def test_network_failure_is_safe():
+    class Boom(CalculNetwork):
+        def match(self, q):
+            raise RuntimeError("boom")
+
+    cyb = CybNodes(conductor=lambda q, ctx: "ok", networks=[Boom()])
+    assert cyb.ask("salut") == "ok"   # un reseau qui plante n'ecroule pas le circuit
+
+
+if __name__ == "__main__":
+    tests = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
+    for t in tests:
+        t()
+        print("OK  ", t.__name__)
+    print("--- %d/%d tests passes ---" % (len(tests), len(tests)))