clovis 0.2.0__tar.gz → 0.4.0__tar.gz

clovis-0.4.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: clovis
+Version: 0.4.0
+Summary: cloooooo — personal LLM client, prompt/context/thinking interface over local Ollama
+Author: Clovis Sfeir
+License: MIT
+Keywords: ai,llm,local-ai,ollama,openai
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: ddgs>=0.1
+Requires-Dist: fastapi>=0.111
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Requires-Dist: uvicorn[standard]>=0.30
+Description-Content-Type: text/markdown
+
+# clovis
+
+Client Python personnel pour un LLM local via [Ollama](https://ollama.com). Interface ultra-simple : `prompt`, `negative_prompt`, `thinking`, `context`.
+
+## Install
+
+```bash
+pip install clovis
+```
+
+## Usage
+
+```python
+from clovis import cloooooo
+
+ai = cloooooo()
+
+# Appel direct
+print(ai("Explique les trous noirs"))
+
+# Avec options
+print(ai(
+    "Génère un poème sur la mer",
+    negative_prompt="pas de rimes",
+    thinking=True,
+    context="Tu es un poète du 19e siècle.",
+))
+
+# Streaming token par token
+for token in ai.stream("Raconte une histoire courte"):
+    print(token, end="", flush=True)
+
+# Conversation avec mémoire
+conv = ai.conversation(context="Tu es un expert en finance.")
+conv("Explique le CAPM")
+conv("Et ses limites ?")  # se souvient de la réponse précédente
+```
+
+## CLI
+
+```bash
+clovis "Explique les trous noirs"           # question directe
+clovis "Génère un poème" --no "sans rimes"  # avec negative prompt
+clovis "Résous ce problème" --think          # mode réflexion
+clovis repl                                  # conversation interactive
+clovis serve --port 8000                     # démarre le serveur API
+```
+
+## API server
+
+```bash
+clovis serve --port 8000 --key sk-montoken
+```
+
+Requête :
+
+```bash
+curl -X POST http://localhost:8000/ia \
+  -H "Authorization: Bearer sk-montoken" \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Bonjour !", "thinking": false}'
+```
+
+Réponse : `{"response": "Bonjour ! Comment puis-je t'aider ?"}`
+
+Streaming : ajouter `"stream": true` → réponse en `text/plain` token par token.
+
+## Config
+
+```bash
+export CLOVIS_MODEL="qwen3-72b-q5km"        # modèle Ollama
+export CLOVIS_OLLAMA_URL="http://localhost:11434"
+export CLOVIS_API_KEY="sk-..."              # clé API pour le serveur
+```

clovis-0.4.0/README.md

@@ -0,0 +1,74 @@
+# clovis
+
+Client Python personnel pour un LLM local via [Ollama](https://ollama.com). Interface ultra-simple : `prompt`, `negative_prompt`, `thinking`, `context`.
+
+## Install
+
+```bash
+pip install clovis
+```
+
+## Usage
+
+```python
+from clovis import cloooooo
+
+ai = cloooooo()
+
+# Appel direct
+print(ai("Explique les trous noirs"))
+
+# Avec options
+print(ai(
+    "Génère un poème sur la mer",
+    negative_prompt="pas de rimes",
+    thinking=True,
+    context="Tu es un poète du 19e siècle.",
+))
+
+# Streaming token par token
+for token in ai.stream("Raconte une histoire courte"):
+    print(token, end="", flush=True)
+
+# Conversation avec mémoire
+conv = ai.conversation(context="Tu es un expert en finance.")
+conv("Explique le CAPM")
+conv("Et ses limites ?")  # se souvient de la réponse précédente
+```
+
+## CLI
+
+```bash
+clovis "Explique les trous noirs"           # question directe
+clovis "Génère un poème" --no "sans rimes"  # avec negative prompt
+clovis "Résous ce problème" --think          # mode réflexion
+clovis repl                                  # conversation interactive
+clovis serve --port 8000                     # démarre le serveur API
+```
+
+## API server
+
+```bash
+clovis serve --port 8000 --key sk-montoken
+```
+
+Requête :
+
+```bash
+curl -X POST http://localhost:8000/ia \
+  -H "Authorization: Bearer sk-montoken" \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Bonjour !", "thinking": false}'
+```
+
+Réponse : `{"response": "Bonjour ! Comment puis-je t'aider ?"}`
+
+Streaming : ajouter `"stream": true` → réponse en `text/plain` token par token.
+
+## Config
+
+```bash
+export CLOVIS_MODEL="qwen3-72b-q5km"        # modèle Ollama
+export CLOVIS_OLLAMA_URL="http://localhost:11434"
+export CLOVIS_API_KEY="sk-..."              # clé API pour le serveur
+```

{clovis-0.2.0 → clovis-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "clovis"
-version = "0.2.0"
+version = "0.4.0"
 description = "cloooooo — personal LLM client, prompt/context/thinking interface over local Ollama"
 readme = "README.md"
 license = { text = "MIT" }
@@ -28,6 +28,7 @@ dependencies = [
     "typer>=0.12",
     "pydantic>=2.0",
     "rich>=13.0",
+    "ddgs>=0.1",
 ]
 
 [project.scripts]

{clovis-0.2.0 → clovis-0.4.0}/src/clovis/__init__.py

@@ -1,4 +1,4 @@
 from ._client import cloooooo
 
 __all__ = ["cloooooo"]
-__version__ = "0.2.0"
+__version__ = "0.4.0"

clovis-0.4.0/src/clovis/_client.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Iterator, Optional
+
+import httpx
+
+_SERVER_URL = "https://cloooooo.com"   # API publique par défaut
+_OLLAMA_URL = "http://localhost:11434"  # fallback local
+_MODEL = "qwen3-32b"
+
+
+def _build_messages(
+    prompt: str,
+    context: Optional[str],
+    negative_prompt: Optional[str],
+    history: list[dict],
+) -> list[dict]:
+    system_parts = []
+    if context:
+        system_parts.append(context)
+    if negative_prompt:
+        system_parts.append(f"Évite absolument dans ta réponse : {negative_prompt}")
+
+    messages = []
+    if system_parts:
+        messages.append({"role": "system", "content": "\n".join(system_parts)})
+    messages.extend(history)
+    messages.append({"role": "user", "content": prompt})
+    return messages
+
+
+class Conversation:
+    def __init__(self, ai: "cloooooo", context: Optional[str] = None) -> None:
+        self._ai = ai
+        self._context = context
+        self._history: list[dict] = []
+
+    def __call__(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False) -> str:
+        messages = _build_messages(prompt, self._context, negative_prompt, self._history)
+        reply = self._ai._send(messages, think=thinking)
+        self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": reply}]
+        return reply
+
+    def stream(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False) -> Iterator[str]:
+        messages = _build_messages(prompt, self._context, negative_prompt, self._history)
+        full = ""
+        for token in self._ai._stream(messages, think=thinking):
+            full += token
+            yield token
+        self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": full}]
+
+    def reset(self) -> None:
+        self._history.clear()
+
+
+class cloooooo:
+    """
+    from clovis import cloooooo
+
+    ai = cloooooo()                        # → cloooooo.com (aucune config requise)
+    ai = cloooooo(local=True)              # → localhost:11434
+    ai = cloooooo(server="http://...")     # → serveur custom
+
+    print(ai("Explique les trous noirs"))
+    print(ai("Écris un poème", negative_prompt="sans rimes", thinking=True))
+    for token in ai.stream("Raconte une histoire"): print(token, end="", flush=True)
+    conv = ai.conversation(context="Tu es un expert en finance")
+    conv("Explique le CAPM") ; conv("Et ses limites ?")
+    """
+
+    def __init__(
+        self,
+        server: Optional[str] = None,
+        *,
+        local: bool = False,
+        ollama_url: Optional[str] = None,
+        model: str = _MODEL,
+    ) -> None:
+        # Priorité : server arg > CLOVIS_SERVER env > cloooooo.com
+        # Si local=True ou CLOVIS_OLLAMA_URL défini → mode Ollama direct
+        env_server = os.getenv("CLOVIS_SERVER")
+        env_ollama = os.getenv("CLOVIS_OLLAMA_URL")
+
+        if local or ollama_url or env_ollama:
+            self._mode = "ollama"
+            self._url = ollama_url or env_ollama or _OLLAMA_URL
+            self._model = os.getenv("CLOVIS_MODEL", model)
+        else:
+            self._mode = "server"
+            self._url = server or env_server or _SERVER_URL
+
+        self._http = httpx.Client()
+
+    def __call__(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False, context: Optional[str] = None, search: bool = False) -> str:
+        if self._mode == "server":
+            return self._call_server(prompt, negative_prompt=negative_prompt, thinking=thinking, context=context, search=search)
+        if search:
+            from ._search import web_search
+            extra = web_search(prompt)
+            if extra:
+                context = f"{extra}\n\n{context}" if context else extra
+        messages = _build_messages(prompt, context, negative_prompt, [])
+        return self._send(messages, think=thinking)
+
+    def stream(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False, context: Optional[str] = None, search: bool = False) -> Iterator[str]:
+        if self._mode == "server":
+            yield from self._stream_server(prompt, negative_prompt=negative_prompt, thinking=thinking, context=context, search=search)
+            return
+        if search:
+            from ._search import web_search
+            extra = web_search(prompt)
+            if extra:
+                context = f"{extra}\n\n{context}" if context else extra
+        messages = _build_messages(prompt, context, negative_prompt, [])
+        yield from self._stream(messages, think=thinking)
+
+    def conversation(self, context: Optional[str] = None) -> Conversation:
+        return Conversation(self, context=context)
+
+    def deep_think(
+        self,
+        prompt: str,
+        *,
+        max_iterations: int = 4,
+        searches_per_step: int = 3,
+        on_progress: "Optional[callable]" = None,
+    ) -> str:
+        if self._mode == "server":
+            resp = self._http.post(
+                f"{self._url}/deep_think",
+                json={"prompt": prompt, "max_iterations": max_iterations, "searches_per_step": searches_per_step},
+                timeout=600,
+            )
+            resp.raise_for_status()
+            return resp.json()["response"]
+        from ._deep_think import deep_think as _dt
+        return _dt(
+            prompt,
+            ollama_url=self._url,
+            model=self._model,
+            max_iterations=max_iterations,
+            searches_per_step=searches_per_step,
+            on_progress=on_progress,
+        )
+
+    def deep_think_stream(
+        self,
+        prompt: str,
+        *,
+        max_iterations: int = 4,
+        searches_per_step: int = 3,
+    ) -> Iterator[str]:
+        if self._mode == "server":
+            with self._http.stream(
+                "POST",
+                f"{self._url}/deep_think",
+                json={"prompt": prompt, "max_iterations": max_iterations, "searches_per_step": searches_per_step, "stream": True},
+                timeout=600,
+            ) as resp:
+                resp.raise_for_status()
+                for chunk in resp.iter_text():
+                    if chunk:
+                        yield chunk
+            return
+        from ._deep_think import deep_think_stream as _dts
+        yield from _dts(
+            prompt,
+            ollama_url=self._url,
+            model=self._model,
+            max_iterations=max_iterations,
+            searches_per_step=searches_per_step,
+        )
+
+    # --- mode server (cloooooo.com/ia) ---
+
+    def _call_server(self, prompt: str, **kwargs) -> str:
+        resp = self._http.post(
+            f"{self._url}/ia",
+            json={"prompt": prompt, **{k: v for k, v in kwargs.items() if v is not None}},
+            timeout=120,
+        )
+        resp.raise_for_status()
+        return resp.json()["response"]
+
+    def _stream_server(self, prompt: str, **kwargs) -> Iterator[str]:
+        with self._http.stream(
+            "POST",
+            f"{self._url}/ia",
+            json={"prompt": prompt, "stream": True, **{k: v for k, v in kwargs.items() if v is not None}},
+            timeout=120,
+        ) as resp:
+            resp.raise_for_status()
+            for chunk in resp.iter_text():
+                if chunk:
+                    yield chunk
+
+    # --- mode ollama (local) ---
+
+    def _send(self, messages: list[dict], think: bool = False) -> str:
+        resp = self._http.post(
+            f"{self._url}/api/chat",
+            json={"model": self._model, "messages": messages, "stream": False, "think": think},
+            timeout=120,
+        )
+        resp.raise_for_status()
+        return resp.json()["message"]["content"]
+
+    def _stream(self, messages: list[dict], think: bool = False) -> Iterator[str]:
+        with self._http.stream(
+            "POST",
+            f"{self._url}/api/chat",
+            json={"model": self._model, "messages": messages, "stream": True, "think": think},
+            timeout=120,
+        ) as resp:
+            resp.raise_for_status()
+            for line in resp.iter_lines():
+                if not line:
+                    continue
+                data = json.loads(line)
+                token = data.get("message", {}).get("content", "")
+                if token:
+                    yield token
+                if data.get("done"):
+                    break
+
+    @classmethod
+    def serve(cls, port: int = 8000, host: str = "0.0.0.0", api_key: Optional[str] = None) -> None:
+        from ._server import start_server
+        start_server(host=host, port=port, api_key=api_key)

clovis-0.4.0/src/clovis/_deep_think.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Iterator
+
+import httpx
+
+_PLAN_SYSTEM = """Tu es un assistant de recherche expert.
+Réponds UNIQUEMENT en JSON valide, sans markdown, sans explication."""
+
+_REFLECT_SYSTEM = """Tu es un analyste de recherche critique.
+Réponds UNIQUEMENT en JSON valide, sans markdown, sans explication."""
+
+_SYNTH_SYSTEM = """Tu es un expert en synthèse d'informations.
+Tu dois produire une réponse complète, structurée et approfondie en te basant uniquement sur les recherches fournies."""
+
+
+def _llm_json(prompt: str, system: str, ollama_url: str, model: str, timeout: int = 60) -> dict:
+    resp = httpx.post(
+        f"{ollama_url}/api/chat",
+        json={
+            "model": model,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": prompt},
+            ],
+            "stream": False,
+            "think": False,
+            "format": "json",
+        },
+        timeout=timeout,
+    )
+    resp.raise_for_status()
+    raw = resp.json()["message"]["content"]
+    # strip markdown fences if model wraps anyway
+    raw = re.sub(r"^```(?:json)?\n?", "", raw.strip())
+    raw = re.sub(r"\n?```$", "", raw.strip())
+    return json.loads(raw)
+
+
+def _llm_text(messages: list[dict], ollama_url: str, model: str, timeout: int = 120, think: bool = False) -> str:
+    resp = httpx.post(
+        f"{ollama_url}/api/chat",
+        json={"model": model, "messages": messages, "stream": False, "think": think},
+        timeout=timeout,
+    )
+    resp.raise_for_status()
+    return resp.json()["message"]["content"]
+
+
+def _llm_stream(messages: list[dict], ollama_url: str, model: str, think: bool = False) -> Iterator[str]:
+    with httpx.stream(
+        "POST",
+        f"{ollama_url}/api/chat",
+        json={"model": model, "messages": messages, "stream": True, "think": think},
+        timeout=300,
+    ) as resp:
+        resp.raise_for_status()
+        for line in resp.iter_lines():
+            if not line:
+                continue
+            data = json.loads(line)
+            token = data.get("message", {}).get("content", "")
+            if token:
+                yield token
+            if data.get("done"):
+                break
+
+
+def _plan(prompt: str, n_queries: int, ollama_url: str, model: str) -> list[str]:
+    """Génère n_queries requêtes de recherche pour répondre au prompt."""
+    result = _llm_json(
+        f"""Question à approfondir : {prompt}
+
+Génère exactement {n_queries} requêtes de recherche web complémentaires et diversifiées pour rassembler toutes les informations nécessaires.
+
+Réponds avec ce JSON :
+{{"queries": ["requête1", "requête2", "requête3"]}}""",
+        _PLAN_SYSTEM,
+        ollama_url,
+        model,
+    )
+    return result.get("queries", [])[:n_queries]
+
+
+def _reflect(
+    prompt: str,
+    accumulated: list[str],
+    iteration: int,
+    max_iterations: int,
+    n_queries: int,
+    ollama_url: str,
+    model: str,
+) -> tuple[bool, list[str]]:
+    """Analyse les lacunes et décide si la recherche est suffisante."""
+    context_summary = "\n\n---\n\n".join(accumulated[-6:])  # garde les 6 derniers blocs
+    result = _llm_json(
+        f"""Question initiale : {prompt}
+
+Informations collectées jusqu'ici (itération {iteration}/{max_iterations}) :
+{context_summary}
+
+Analyse :
+1. Est-ce qu'on a suffisamment d'informations pour répondre complètement et avec précision ?
+2. Quelles lacunes importantes subsistent ?
+3. Génère {n_queries} nouvelles requêtes pour combler ces lacunes.
+
+Réponds avec ce JSON :
+{{"satisfied": true/false, "missing": "description des lacunes", "follow_up_queries": ["q1", "q2", "q3"]}}""",
+        _REFLECT_SYSTEM,
+        ollama_url,
+        model,
+        timeout=90,
+    )
+    satisfied = result.get("satisfied", False)
+    queries = result.get("follow_up_queries", [])[:n_queries]
+    return satisfied, queries
+
+
+def _extract(
+    prompt: str, search_results: str, ollama_url: str, model: str
+) -> str:
+    """Extrait et résume les informations pertinentes des résultats de recherche."""
+    return _llm_text(
+        [
+            {
+                "role": "system",
+                "content": "Tu es un extracteur d'information précis. Résume uniquement ce qui est pertinent pour la question.",
+            },
+            {
+                "role": "user",
+                "content": f"""Question : {prompt}
+
+Résultats de recherche :
+{search_results}
+
+Extrais et résume les informations clés et pertinentes en 3-5 points.""",
+            },
+        ],
+        ollama_url,
+        model,
+        timeout=90,
+    )
+
+
+def deep_think(
+    prompt: str,
+    ollama_url: str = "http://localhost:11434",
+    model: str = "qwen3-32b",
+    max_iterations: int = 4,
+    searches_per_step: int = 3,
+    on_progress: "callable | None" = None,
+) -> str:
+    """
+    Recherche approfondie multi-itérations avec accès internet.
+
+    Boucle : plan → search → extract → reflect → (repeat) → synthesize
+    """
+    from ._search import web_search
+
+    def _log(msg: str):
+        if on_progress:
+            on_progress(msg)
+
+    all_context: list[str] = []
+
+    # Étape 1 : Planification
+    _log(f"[plan] Génération du plan de recherche...")
+    queries = _plan(prompt, searches_per_step, ollama_url, model)
+    _log(f"[plan] {len(queries)} requêtes générées : {queries}")
+
+    for iteration in range(1, max_iterations + 1):
+        _log(f"[iter {iteration}/{max_iterations}] Recherche en cours...")
+
+        # Étape 2 : Recherche
+        raw_results = []
+        for q in queries:
+            _log(f"[search] → {q}")
+            result = web_search(q, max_results=5)
+            if result:
+                raw_results.append(result)
+
+        if not raw_results:
+            _log("[search] Aucun résultat trouvé, arrêt.")
+            break
+
+        combined = "\n\n".join(raw_results)
+
+        # Étape 3 : Extraction
+        _log(f"[extract] Analyse des résultats...")
+        summary = _extract(prompt, combined, ollama_url, model)
+        all_context.append(f"=== Itération {iteration} ===\n{summary}")
+        _log(f"[extract] ✓ {len(summary)} chars extraits")
+
+        # Étape 4 : Réflexion (pas à la dernière itération)
+        if iteration < max_iterations:
+            _log(f"[reflect] Analyse des lacunes...")
+            satisfied, queries = _reflect(
+                prompt, all_context, iteration, max_iterations, searches_per_step, ollama_url, model
+            )
+            _log(f"[reflect] Satisfait={satisfied}, nouvelles requêtes={queries}")
+            if satisfied:
+                _log(f"[reflect] Recherche jugée complète à l'itération {iteration}.")
+                break
+
+    # Étape 5 : Synthèse finale
+    _log(f"[synthesize] Génération de la réponse finale...")
+    full_context = "\n\n".join(all_context)
+    final_messages = [
+        {"role": "system", "content": _SYNTH_SYSTEM},
+        {
+            "role": "user",
+            "content": f"""Question : {prompt}
+
+Résultats de recherche approfondis ({len(all_context)} itérations) :
+{full_context}
+
+Fournis une réponse complète, structurée, sourcée et approfondie à cette question.
+Utilise des titres, des points clés, et cite les faits importants trouvés dans la recherche.""",
+        },
+    ]
+    answer = _llm_text(final_messages, ollama_url, model, timeout=300, think=True)
+    _log(f"[synthesize] ✓ Réponse générée ({len(answer)} chars)")
+    return answer
+
+
+def deep_think_stream(
+    prompt: str,
+    ollama_url: str = "http://localhost:11434",
+    model: str = "qwen3:14b",
+    max_iterations: int = 4,
+    searches_per_step: int = 3,
+) -> Iterator[str]:
+    """
+    Version streaming : yield des tokens de progression puis la réponse finale.
+    Les lignes commençant par '[' sont des logs de progression.
+    """
+    from ._search import web_search
+
+    all_context: list[str] = []
+
+    yield f"[plan] Génération du plan de recherche...\n"
+    queries = _plan(prompt, searches_per_step, ollama_url, model)
+    yield f"[plan] Requêtes : {', '.join(queries)}\n"
+
+    for iteration in range(1, max_iterations + 1):
+        yield f"[iter {iteration}/{max_iterations}] Recherche...\n"
+
+        raw_results = []
+        for q in queries:
+            yield f"[search] → {q}\n"
+            result = web_search(q, max_results=5)
+            if result:
+                raw_results.append(result)
+
+        if not raw_results:
+            break
+
+        combined = "\n\n".join(raw_results)
+        yield f"[extract] Analyse...\n"
+        summary = _extract(prompt, combined, ollama_url, model)
+        all_context.append(f"=== Itération {iteration} ===\n{summary}")
+
+        if iteration < max_iterations:
+            satisfied, queries = _reflect(
+                prompt, all_context, iteration, max_iterations, searches_per_step, ollama_url, model
+            )
+            yield f"[reflect] Satisfait={satisfied}\n"
+            if satisfied:
+                break
+
+    yield f"[synthesize] Génération de la réponse finale...\n\n"
+
+    full_context = "\n\n".join(all_context)
+    final_messages = [
+        {"role": "system", "content": _SYNTH_SYSTEM},
+        {
+            "role": "user",
+            "content": f"""Question : {prompt}
+
+Résultats de recherche approfondis ({len(all_context)} itérations) :
+{full_context}
+
+Fournis une réponse complète, structurée, sourcée et approfondie.""",
+        },
+    ]
+    yield from _llm_stream(final_messages, ollama_url, model, think=True)

clovis-0.4.0/src/clovis/_search.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+
+def web_search(query: str, max_results: int = 4) -> str:
+    """Retourne un bloc de contexte avec les résultats DuckDuckGo."""
+    try:
+        from ddgs import DDGS
+    except ImportError:
+        return ""
+
+    try:
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=max_results))
+    except Exception:
+        return ""
+
+    if not results:
+        return ""
+
+    lines = [f"- {r['title']}: {r['body']}" for r in results]
+    return "Résultats de recherche web (utilise ces informations pour répondre) :\n" + "\n".join(lines)

{clovis-0.2.0 → clovis-0.4.0}/src/clovis/_server.py

@@ -14,17 +14,25 @@ from ._client import cloooooo
 _bearer = HTTPBearer(auto_error=False)
 
 
+class DeepThinkRequest(BaseModel):
+    prompt: str
+    max_iterations: int = 4
+    searches_per_step: int = 3
+    stream: bool = False
+
+
 class IARequest(BaseModel):
     prompt: str
     negative_prompt: Optional[str] = None
     thinking: bool = False
     context: Optional[str] = None
     stream: bool = False
+    search: bool = False
 
 
 def build_app(api_key: Optional[str] = None) -> FastAPI:
-    app = FastAPI(title="cloooooo", version="0.1.0")
-    ai = cloooooo()
+    app = FastAPI(title="cloooooo", version="0.4.0")
+    ai = cloooooo(local=True)
 
     def _check_key(creds: Optional[HTTPAuthorizationCredentials] = Depends(_bearer)):
         if api_key and (not creds or creds.credentials != api_key):
@@ -32,10 +40,17 @@ def build_app(api_key: Optional[str] = None) -> FastAPI:
 
     @app.post("/ia", dependencies=[Depends(_check_key)])
     async def ia(req: IARequest):
+        context = req.context
+        if req.search:
+            from ._search import web_search
+            search_ctx = web_search(req.prompt)
+            if search_ctx:
+                context = f"{search_ctx}\n\n{context}" if context else search_ctx
+
         kwargs = dict(
             negative_prompt=req.negative_prompt,
             thinking=req.thinking,
-            context=req.context,
+            context=context,
         )
         if req.stream:
             def generate():
@@ -45,9 +60,23 @@ def build_app(api_key: Optional[str] = None) -> FastAPI:
 
         return {"response": ai(req.prompt, **kwargs)}
 
+    @app.post("/deep_think", dependencies=[Depends(_check_key)])
+    async def deep_think_endpoint(req: DeepThinkRequest):
+        from ._deep_think import deep_think as _dt, deep_think_stream as _dts
+        ollama_url = ai._url
+        model = ai._model
+        if req.stream:
+            def generate():
+                yield from _dts(req.prompt, ollama_url=ollama_url, model=model,
+                                max_iterations=req.max_iterations, searches_per_step=req.searches_per_step)
+            return StreamingResponse(generate(), media_type="text/plain")
+        answer = _dt(req.prompt, ollama_url=ollama_url, model=model,
+                     max_iterations=req.max_iterations, searches_per_step=req.searches_per_step)
+        return {"response": answer}
+
     @app.get("/")
     def root():
-        return {"status": "ok", "endpoint": "/ia"}
+        return {"status": "ok", "endpoints": ["/ia", "/deep_think"]}
 
     return app
 

clovis-0.4.0/test_live.py

@@ -0,0 +1,108 @@
+"""Test live end-to-end — lance avec : python3 test_live.py"""
+import os
+import sys
+
+
+def test_import():
+    from clovis import cloooooo
+    ai = cloooooo()
+    print(f"  import OK — modèle: {ai._model}, url: {ai._url}")
+
+
+def test_basic_call():
+    from clovis import cloooooo
+    ai = cloooooo()
+    resp = ai('Réponds uniquement par le mot "ok".')
+    assert isinstance(resp, str) and len(resp) > 0
+    print(f"  appel OK — réponse: {resp!r}")
+
+
+def test_negative_prompt():
+    from clovis import cloooooo
+    ai = cloooooo()
+    resp = ai("Présente-toi en 10 mots.", negative_prompt="ne mentionne pas ton nom")
+    assert isinstance(resp, str) and len(resp) > 0
+    print(f"  negative_prompt OK — réponse: {resp!r}")
+
+
+def test_thinking():
+    from clovis import cloooooo
+    ai = cloooooo()
+    resp = ai("Combien font 17 × 23 ?", thinking=True)
+    assert isinstance(resp, str) and len(resp) > 0
+    print(f"  thinking OK — réponse: {resp!r}")
+
+
+def test_context():
+    from clovis import cloooooo
+    ai = cloooooo()
+    resp = ai("Comment ça va ?", context="Tu es un pirate des Caraïbes. Réponds toujours en argot de marin.")
+    assert isinstance(resp, str) and len(resp) > 0
+    print(f"  context OK — réponse: {resp!r}")
+
+
+def test_stream():
+    from clovis import cloooooo
+    ai = cloooooo()
+    tokens = list(ai.stream("Compte jusqu'à 5, un nombre par ligne."))
+    assert len(tokens) > 0
+    full = "".join(tokens)
+    assert len(full) > 0
+    print(f"  stream OK — {len(tokens)} tokens, texte: {full!r}")
+
+
+def test_conversation():
+    from clovis import cloooooo
+    ai = cloooooo()
+    conv = ai.conversation(context="Réponds toujours en une seule phrase courte.")
+    r1 = conv("Mon prénom est Clovis.")
+    r2 = conv("Quel est mon prénom ?")
+    assert "Clovis" in r2 or "clovis" in r2.lower(), f"Prénom pas mémorisé: {r2!r}"
+    print(f"  conversation OK — mémoire: {r2!r}")
+
+
+def test_conversation_stream():
+    from clovis import cloooooo
+    ai = cloooooo()
+    conv = ai.conversation()
+    tokens = list(conv.stream("Dis bonjour en 3 langues."))
+    full = "".join(tokens)
+    assert len(full) > 0
+    print(f"  conversation stream OK — {len(tokens)} tokens")
+
+
+def test_conversation_reset():
+    from clovis import cloooooo
+    ai = cloooooo()
+    conv = ai.conversation()
+    conv("Mon prénom est Clovis.")
+    conv.reset()
+    assert len(conv._history) == 0
+    print("  conversation reset OK")
+
+
+if __name__ == "__main__":
+    tests = [
+        test_import,
+        test_basic_call,
+        test_negative_prompt,
+        test_thinking,
+        test_context,
+        test_stream,
+        test_conversation,
+        test_conversation_stream,
+        test_conversation_reset,
+    ]
+    passed = 0
+    for t in tests:
+        print(f"\n{t.__name__}")
+        try:
+            t()
+            passed += 1
+        except Exception as e:
+            print(f"  FAILED: {e}")
+            import traceback; traceback.print_exc()
+
+    print(f"\n{'='*40}")
+    print(f"Résultat: {passed}/{len(tests)} tests passés")
+    sys.exit(0 if passed == len(tests) else 1)

clovis-0.2.0/PKG-INFO

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: clovis
-Version: 0.2.0
-Summary: cloooooo — personal LLM client, prompt/context/thinking interface over local Ollama
-Author: Clovis Sfeir
-License: MIT
-Keywords: ai,llm,local-ai,ollama,openai
-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.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.10
-Requires-Dist: fastapi>=0.111
-Requires-Dist: httpx>=0.27
-Requires-Dist: pydantic>=2.0
-Requires-Dist: rich>=13.0
-Requires-Dist: typer>=0.12
-Requires-Dist: uvicorn[standard]>=0.30
-Description-Content-Type: text/markdown
-
-# clovis
-
-OpenAI-compatible Python client over a local [Ollama](https://ollama.com) instance.
-
-## Install
-
-```bash
-pip install clovis
-```
-
-## Usage
-
-```python
-from clovis import cloooooo
-
-client = cloooooo()  # connects to localhost:11434 by default
-
-# Chat
-resp = client.chat.completions.create(
-    model="qwen3-72b",
-    messages=[{"role": "user", "content": "Bonjour !"}]
-)
-print(resp.choices[0].message.content)
-
-# Streaming
-for chunk in client.chat.completions.create(
-    messages=[{"role": "user", "content": "Écris un poème"}],
-    stream=True,
-):
-    print(chunk.choices[0].delta.get("content", ""), end="", flush=True)
-
-# Conversation with auto history
-with client.conversation(system="Tu es un expert en finance.") as conv:
-    print(conv.chat("Explique le CAPM"))
-    print(conv.chat("Et ses limites ?"))  # remembers context
-
-# Start API server
-cloooooo.serve(port=8000, api_key="sk-...")
-```
-
-## CLI
-
-```bash
-clovis "Explique les trous noirs"   # direct question
-clovis repl                          # interactive conversation
-clovis serve --port 8000             # start API server
-```
-
-## Config
-
-```bash
-export CLOVIS_MODEL="qwen3-72b"
-export CLOVIS_OLLAMA_URL="http://localhost:11434"
-export CLOVIS_API_KEY="sk-..."
-```

clovis-0.2.0/README.md

@@ -1,55 +0,0 @@
-# clovis
-
-OpenAI-compatible Python client over a local [Ollama](https://ollama.com) instance.
-
-## Install
-
-```bash
-pip install clovis
-```
-
-## Usage
-
-```python
-from clovis import cloooooo
-
-client = cloooooo()  # connects to localhost:11434 by default
-
-# Chat
-resp = client.chat.completions.create(
-    model="qwen3-72b",
-    messages=[{"role": "user", "content": "Bonjour !"}]
-)
-print(resp.choices[0].message.content)
-
-# Streaming
-for chunk in client.chat.completions.create(
-    messages=[{"role": "user", "content": "Écris un poème"}],
-    stream=True,
-):
-    print(chunk.choices[0].delta.get("content", ""), end="", flush=True)
-
-# Conversation with auto history
-with client.conversation(system="Tu es un expert en finance.") as conv:
-    print(conv.chat("Explique le CAPM"))
-    print(conv.chat("Et ses limites ?"))  # remembers context
-
-# Start API server
-cloooooo.serve(port=8000, api_key="sk-...")
-```
-
-## CLI
-
-```bash
-clovis "Explique les trous noirs"   # direct question
-clovis repl                          # interactive conversation
-clovis serve --port 8000             # start API server
-```
-
-## Config
-
-```bash
-export CLOVIS_MODEL="qwen3-72b"
-export CLOVIS_OLLAMA_URL="http://localhost:11434"
-export CLOVIS_API_KEY="sk-..."
-```

clovis-0.2.0/src/clovis/_client.py

@@ -1,154 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from typing import Iterator, Optional
-
-import httpx
-
-_OLLAMA_URL = "http://localhost:11434"
-_MODEL = "qwen3-72b-q5km"
-
-
-def _build_messages(
-    prompt: str,
-    context: Optional[str],
-    negative_prompt: Optional[str],
-    thinking: bool,
-    history: list[dict],
-) -> list[dict]:
-    system_parts = []
-    if context:
-        system_parts.append(context)
-    if negative_prompt:
-        system_parts.append(f"Évite absolument dans ta réponse : {negative_prompt}")
-    if thinking:
-        system_parts.append("Réfléchis étape par étape avant de répondre.")
-
-    messages = []
-    if system_parts:
-        messages.append({"role": "system", "content": "\n".join(system_parts)})
-    messages.extend(history)
-    messages.append({"role": "user", "content": prompt})
-    return messages
-
-
-class Conversation:
-    def __init__(self, ai: "cloooooo", context: Optional[str] = None) -> None:
-        self._ai = ai
-        self._context = context
-        self._history: list[dict] = []
-
-    def __call__(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        thinking: bool = False,
-    ) -> str:
-        messages = _build_messages(prompt, self._context, negative_prompt, thinking, self._history)
-        reply = self._ai._send(messages)
-        self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": reply}]
-        return reply
-
-    def stream(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        thinking: bool = False,
-    ) -> Iterator[str]:
-        messages = _build_messages(prompt, self._context, negative_prompt, thinking, self._history)
-        full = ""
-        for token in self._ai._stream(messages):
-            full += token
-            yield token
-        self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": full}]
-
-    def reset(self) -> None:
-        self._history.clear()
-
-
-class cloooooo:
-    """
-    Usage::
-
-        from clovis import cloooooo
-
-        ai = cloooooo()
-        print(ai("Explique les trous noirs"))
-        print(ai("Génère un poème", negative_prompt="pas de rimes", thinking=True))
-
-        for token in ai.stream("Raconte une histoire"):
-            print(token, end="", flush=True)
-
-        conv = ai.conversation(context="Tu es un expert en finance")
-        conv("Explique le CAPM")
-        conv("Et ses limites ?")  # se souvient du contexte
-    """
-
-    def __init__(
-        self,
-        ollama_url: str = _OLLAMA_URL,
-        model: str = _MODEL,
-    ) -> None:
-        self._url = os.getenv("CLOVIS_OLLAMA_URL", ollama_url)
-        self._model = os.getenv("CLOVIS_MODEL", model)
-        self._http = httpx.Client()
-
-    def __call__(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        thinking: bool = False,
-        context: Optional[str] = None,
-    ) -> str:
-        messages = _build_messages(prompt, context, negative_prompt, thinking, [])
-        return self._send(messages)
-
-    def stream(
-        self,
-        prompt: str,
-        *,
-        negative_prompt: Optional[str] = None,
-        thinking: bool = False,
-        context: Optional[str] = None,
-    ) -> Iterator[str]:
-        messages = _build_messages(prompt, context, negative_prompt, thinking, [])
-        return self._stream(messages)
-
-    def conversation(self, context: Optional[str] = None) -> Conversation:
-        return Conversation(self, context=context)
-
-    def _send(self, messages: list[dict]) -> str:
-        resp = self._http.post(
-            f"{self._url}/api/chat",
-            json={"model": self._model, "messages": messages, "stream": False},
-            timeout=600,
-        )
-        resp.raise_for_status()
-        return resp.json()["message"]["content"]
-
-    def _stream(self, messages: list[dict]) -> Iterator[str]:
-        with self._http.stream(
-            "POST",
-            f"{self._url}/api/chat",
-            json={"model": self._model, "messages": messages, "stream": True},
-            timeout=600,
-        ) as resp:
-            resp.raise_for_status()
-            for line in resp.iter_lines():
-                if not line:
-                    continue
-                data = json.loads(line)
-                token = data.get("message", {}).get("content", "")
-                if token:
-                    yield token
-                if data.get("done"):
-                    break
-
-    @classmethod
-    def serve(cls, port: int = 8000, host: str = "0.0.0.0", api_key: Optional[str] = None) -> None:
-        from ._server import start_server
-        start_server(host=host, port=port, api_key=api_key)

clovis-0.2.0/test_live.py

@@ -1,78 +0,0 @@
-"""Test live end-to-end — lance avec : python3 test_live.py"""
-from clovis import cloooooo, ClovisConnectionError, ClovisModelNotFound
-
-TEST_MODEL = "gemma3:4b"  # petit modèle pour le test, qwen3-72b-q5km après
-
-def test_basic_chat():
-    client = cloooooo(model=TEST_MODEL)
-    resp = client.chat.completions.create(
-        messages=[{"role": "user", "content": "Réponds juste 'ok' et rien d'autre."}]
-    )
-    assert resp.choices[0].message.content
-    assert resp.choices[0].message.role == "assistant"
-    assert resp.usage.total_tokens > 0
-    print(f"  chat OK — réponse : {resp.choices[0].message.content!r}")
-
-def test_streaming():
-    client = cloooooo(model=TEST_MODEL)
-    chunks = list(client.chat.completions.create(
-        messages=[{"role": "user", "content": "Dis juste 'bonjour'."}],
-        stream=True,
-    ))
-    full = "".join(c.choices[0].delta.get("content", "") for c in chunks)
-    assert len(full) > 0
-    print(f"  streaming OK — {len(chunks)} chunks, texte : {full!r}")
-
-def test_conversation():
-    client = cloooooo(model=TEST_MODEL)
-    with client.conversation(system="Réponds toujours en une seule phrase.") as conv:
-        r1 = conv.chat("Mon prénom est Clovis.")
-        r2 = conv.chat("Quel est mon prénom ?")
-    assert "Clovis" in r2 or "clovis" in r2.lower()
-    assert len(conv.history) == 5  # system + 2x (user+assistant)
-    print(f"  conversation OK — mémoire : {r2!r}")
-
-def test_models_list():
-    client = cloooooo(model=TEST_MODEL)
-    models = client.models()
-    assert isinstance(models, list)
-    assert len(models) > 0
-    print(f"  models() OK — {models}")
-
-def test_model_not_found():
-    client = cloooooo(model="inexistant:99b")
-    try:
-        client.chat.completions.create(
-            messages=[{"role": "user", "content": "test"}]
-        )
-        assert False, "Aurait dû lever ClovisModelNotFound"
-    except ClovisModelNotFound as e:
-        print(f"  ClovisModelNotFound OK — {e}")
-
-def test_connection_error():
-    try:
-        cloooooo(ollama_url="http://localhost:9999")
-        assert False, "Aurait dû lever ClovisConnectionError"
-    except ClovisConnectionError as e:
-        print(f"  ClovisConnectionError OK — {e}")
-
-if __name__ == "__main__":
-    tests = [
-        test_basic_chat,
-        test_streaming,
-        test_conversation,
-        test_models_list,
-        test_model_not_found,
-        test_connection_error,
-    ]
-    passed = 0
-    for t in tests:
-        print(f"\n{t.__name__}")
-        try:
-            t()
-            passed += 1
-        except Exception as e:
-            print(f"  FAILED: {e}")
-
-    print(f"\n{'='*40}")
-    print(f"Résultat : {passed}/{len(tests)} tests passés")