clovis 0.3.0__tar.gz → 0.4.0__tar.gz

{clovis-0.3.0 → clovis-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clovis
-Version: 0.3.0
+Version: 0.4.0
 Summary: cloooooo — personal LLM client, prompt/context/thinking interface over local Ollama
 Author: Clovis Sfeir
 License: MIT
@@ -14,6 +14,7 @@ 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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "clovis"
-version = "0.3.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.3.0 → clovis-0.4.0}/src/clovis/__init__.py

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

{clovis-0.3.0 → clovis-0.4.0}/src/clovis/_client.py

@@ -8,14 +8,13 @@ import httpx
 
 _SERVER_URL = "https://cloooooo.com"   # API publique par défaut
 _OLLAMA_URL = "http://localhost:11434"  # fallback local
-_MODEL = "qwen3:14b"
+_MODEL = "qwen3-32b"
 
 
 def _build_messages(
     prompt: str,
     context: Optional[str],
     negative_prompt: Optional[str],
-    thinking: bool,
     history: list[dict],
 ) -> list[dict]:
     system_parts = []
@@ -23,8 +22,6 @@ def _build_messages(
         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:
@@ -41,15 +38,15 @@ class Conversation:
         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)
+        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, thinking, self._history)
+        messages = _build_messages(prompt, self._context, negative_prompt, self._history)
         full = ""
-        for token in self._ai._stream(messages):
+        for token in self._ai._stream(messages, think=thinking):
             full += token
             yield token
         self._history += [{"role": "user", "content": prompt}, {"role": "assistant", "content": full}]
@@ -96,22 +93,86 @@ class cloooooo:
 
         self._http = httpx.Client()
 
-    def __call__(self, prompt: str, *, negative_prompt: Optional[str] = None, thinking: bool = False, context: Optional[str] = None) -> str:
+    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)
-        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]:
+            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)
+            yield from self._stream_server(prompt, negative_prompt=negative_prompt, thinking=thinking, context=context, search=search)
             return
-        messages = _build_messages(prompt, context, negative_prompt, thinking, [])
-        yield from self._stream(messages)
+        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:
@@ -137,20 +198,20 @@ class cloooooo:
 
     # --- mode ollama (local) ---
 
-    def _send(self, messages: list[dict]) -> str:
+    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": False},
+            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]) -> Iterator[str]:
+    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": False},
+            json={"model": self._model, "messages": messages, "stream": True, "think": think},
             timeout=120,
         ) as resp:
             resp.raise_for_status()

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.3.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