Déploiement final Kibali : Code + Modèle complet

.gitattributes

@@ -0,0 +1 @@
+model_cache/** filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+.env
+*.pyc

README.md

@@ -0,0 +1,18 @@
+---
+title: Kibali IA Pro
+emoji: 🦁
+colorFrom: yellow
+colorTo: black
+sdk: streamlit
+sdk_version: 1.31.0
+app_file: app.py
+pinned: false
+---
+
+# Kibali IA Pro - Agentic RAG
+Assistant intelligent optimisé pour le contexte gabonais, utilisant une architecture RAG avec mémoire FAISS et recherche hybride.
+
+## Configuration locale
+1. Clonez le repository.
+2. Créez un fichier `.env` avec votre `TAVILY_API_KEY`.
+3. Installez les dépendances : `pip install -r requirements.txt`.

agent.py

@@ -0,0 +1,72 @@
+from langchain.agents import create_react_agent, AgentExecutor
+from langchain.memory import ConversationBufferMemory
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain.prompts import PromptTemplate
+from langchain_openai import ChatOpenAI
+from tools.web import web_search_tool
+from tools.local_docs import local_knowledge_tool
+import os
+
+def create_agent():
+    llm = ChatOpenAI(
+        model="gpt-4o-mini",
+        temperature=0.2
+    )
+
+    tools = [
+        local_knowledge_tool,
+        web_search_tool,
+    ]
+
+    prompt = PromptTemplate.from_template(
+        """Tu es Kibali, un agent IA avancé.
+
+CAPACITÉS :
+- Base de connaissances locale
+- Recherche web Tavily
+
+RÈGLES :
+1. Base locale TOUJOURS en premier
+2. Web seulement si nécessaire
+3. Cite les sources
+4. Mentionne les contradictions
+
+FORMAT ReAct STRICT :
+
+Question: {input}
+Thought: raisonnement
+Action: outil
+Action Input: entrée
+Observation: résultat
+...
+Final Answer: réponse claire
+
+Commence !
+
+Question: {input}
+Thought: {agent_scratchpad}
+"""
+    )
+
+    agent = create_react_agent(
+        llm=llm,
+        tools=tools,
+        prompt=prompt
+    )
+
+    memory = ConversationBufferMemory(
+        memory_key="chat_history",
+        return_messages=True
+    )
+
+    executor = AgentExecutor(
+        agent=agent,
+        tools=tools,
+        memory=memory,
+        verbose=True,
+        max_iterations=5,
+        handle_parsing_errors=True
+    )
+
+    return executor

app.py

@@ -0,0 +1,190 @@
+import streamlit as st
+import pandas as pd
+import folium
+from streamlit_folium import st_folium
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer, BitsAndBytesConfig
+from sentence_transformers import SentenceTransformer
+import torch
+import faiss
+import numpy as np
+from threading import Thread
+import os
+import base64
+from streamlit_js_eval import streamlit_js_eval
+
+# Imports outils personnalisés
+from tools.web import web_search
+from tools.todo import execute_reflection_plan
+from tools.geo import get_geo_context
+
+# --- CONFIGURATION ---
+st.set_page_config(
+    page_title="Kibali AI Pro - Agentic RAG", 
+    page_icon="🦁", 
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+LOGO_PATH = "/home/belikan/geoscan/agent_kibali/kibali_logo.svg"
+MODEL_PATH = "/home/belikan/geoscan/agent_kibali/model_cache"
+
+def get_base64_svg(path):
+    try:
+        with open(path, "rb") as f:
+            return base64.b64encode(f.read()).decode()
+    except Exception: return None
+
+def apply_custom_css(filters):
+    logo_base64 = get_base64_svg(LOGO_PATH)
+    logo_html = f'<div style="display: flex; justify-content: center; margin-top: -75px; margin-bottom: 20px;"><img src="data:image/svg+xml;base64,{logo_base64}" width="120"></div>' if logo_base64 else ""
+    st.markdown(f"""
+        <style>
+        .stChatMessage {{ border-radius: 15px; margin-bottom: 10px; border: 1px solid #303030; }}
+        .main {{ background-color: #0e1117; }}
+        .leaflet-tile-container {{ filter: brightness({filters['brightness']}%) contrast({filters['contrast']}%) saturate({filters['saturate']}%) invert({filters['invert']}%); }}
+        </style>
+        {logo_html}
+        """, unsafe_allow_html=True)
+
+@st.cache_resource
+def init_resources():
+    embed_model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, local_files_only=True)
+    if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token
+    
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_use_double_quant=True,
+        bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.float16
+    )
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_PATH, quantization_config=bnb_config, device_map="auto",
+        torch_dtype=torch.float16, trust_remote_code=True
+    )
+    return embed_model, model, tokenizer
+
+embed_model, model, tokenizer = init_resources()
+
+# --- INITIALISATION MÉMOIRE ---
+if "vector_index" not in st.session_state:
+    st.session_state.vector_index = faiss.IndexFlatL2(384)
+    st.session_state.memory_text = []
+
+if "messages" not in st.session_state: st.session_state.messages = []
+if "map_filters" not in st.session_state:
+    st.session_state.map_filters = {"brightness": 100, "contrast": 100, "saturate": 100, "invert": 0}
+
+# --- GÉOLOCALISATION ---
+if "geo" not in st.session_state: st.session_state.geo = get_geo_context()
+loc = streamlit_js_eval(js_expressions="""new Promise((resolve) => { navigator.geolocation.getCurrentPosition((pos) => { resolve({ coords: { latitude: pos.coords.latitude, longitude: pos.coords.longitude } }); }, (err) => resolve(null)); });""", want_output=True)
+if loc and loc.get('coords'):
+    st.session_state.geo.update({"latitude": loc['coords']['latitude'], "longitude": loc['coords']['longitude'], "method": "GPS"})
+
+apply_custom_css(st.session_state.map_filters)
+
+# --- SIDEBAR ---
+with st.sidebar:
+    st.image(LOGO_PATH if os.path.exists(LOGO_PATH) else "https://img.icons8.com/fluent/96/lion.png", width=80)
+    st.title("Kibali OS v3")
+    with st.expander("📍 Carte & Géo", expanded=True):
+        m = folium.Map(location=[st.session_state.geo['latitude'], st.session_state.geo['longitude']], zoom_start=15)
+        folium.Marker([st.session_state.geo['latitude'], st.session_state.geo['longitude']], icon=folium.Icon(color="red")).add_to(m)
+        st_folium(m, height=250, use_container_width=True)
+    
+    thinking_mode = st.toggle("🧠 Réflexion Agentique", value=True)
+    if st.button("🗑️ Reset Chat"):
+        st.session_state.messages = []
+        st.session_state.memory_text = []
+        st.session_state.vector_index = faiss.IndexFlatL2(384)
+        st.rerun()
+
+# --- AFFICHAGE HISTORIQUE ---
+for msg in st.session_state.messages:
+    with st.chat_message(msg["role"], avatar=LOGO_PATH if msg["role"] == "assistant" else "user"):
+        st.markdown(msg["content"])
+
+# --- LOGIQUE CHAT ---
+if prompt := st.chat_input("Posez votre question..."):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user", avatar="user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant", avatar=LOGO_PATH):
+        if thinking_mode:
+            # Passage de l'historique pour la réflexion
+            execute_reflection_plan(prompt, st.session_state.geo, st.session_state.messages[:-1])
+
+        with st.status("🔍 Analyse du fil de discussion...", expanded=False) as status:
+            # 1. REFORMULATION DE LA REQUÊTE (Pour des images précises)
+            # Si la question est courte, on lui injecte le contexte du dernier message
+            search_query = prompt
+            if len(prompt.split()) < 4 and len(st.session_state.messages) > 1:
+                last_context = st.session_state.messages[-2]['content']
+                search_query = f"Gabon {prompt} {last_context[:60]}"
+
+            # 2. CONTEXTE IMMÉDIAT
+            recent_history = ""
+            if len(st.session_state.messages) > 1:
+                for m in st.session_state.messages[-4:-1]:
+                    recent_history += f"{m['role'].upper()}: {m['content']}\n"
+
+            # 3. RÉCUPÉRATION MÉMOIRE LONG TERME (FAISS)
+            past_ctx = ""
+            if st.session_state.vector_index.ntotal > 0:
+                query_vec = embed_model.encode([prompt]).astype('float32')
+                D, I = st.session_state.vector_index.search(query_vec, k=2)
+                past_ctx = "\n".join([st.session_state.memory_text[i] for i in I[0] if i != -1])
+
+            # 4. RECHERCHE WEB (Utilise la recherche reformulée pour les images)
+            search_data = web_search(search_query)
+            web_ctx = "\n".join([f"- {r['content'][:300]}" for r in search_data.get("results", [])])
+            imgs = search_data.get("images", [])[:3]
+            status.update(label="Contexte stabilisé", state="complete")
+
+        if imgs:
+            st.write("🖼️ **Sources visuelles :**")
+            im_cols = st.columns(len(imgs))
+            for i, url in enumerate(imgs): im_cols[i].image(url, use_container_width=True)
+
+        # 5. GÉNÉRATION AVEC PROMPT RENFORCÉ
+        placeholder = st.empty()
+        full_response = ""
+        
+        sys_instr = (
+            f"Tu es Kibali, assistant intelligent au Gabon ({st.session_state.geo['city']}). "
+            f"Reste strictement dans le sujet de l'HISTORIQUE RÉCENT. "
+            f"L'utilisateur parle de sport ou d'actualité, ne donne pas de définitions générales."
+        )
+        
+        final_prompt = (
+            f"### SYSTEM: {sys_instr}\n"
+            f"### HISTORIQUE RÉCENT:\n{recent_history}\n"
+            f"### MÉMOIRE FAISS:\n{past_ctx}\n"
+            f"### CONTEXTE WEB:\n{web_ctx}\n"
+            f"### QUESTION: {prompt}\n"
+            f"### RÉPONSE DE KIBALI:"
+        )
+
+        inputs = tokenizer(final_prompt, return_tensors="pt").to(model.device)
+        streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+        
+        gen_thread = Thread(target=model.generate, kwargs=dict(
+            **inputs, streamer=streamer, max_new_tokens=800, 
+            temperature=0.3, # Température basse pour la précision contextuelle
+            do_sample=True, pad_token_id=tokenizer.eos_token_id
+        ))
+        gen_thread.start()
+
+        for token in streamer:
+            if "###" in token: break
+            full_response += token
+            placeholder.markdown(full_response + "▌")
+        placeholder.markdown(full_response)
+
+        # 6. SAUVEGARDE & INDEXATION
+        st.session_state.messages.append({"role": "assistant", "content": full_response})
+        
+        new_mem = f"Q: {prompt} | R: {full_response}"
+        st.session_state.memory_text.append(new_mem)
+        st.session_state.vector_index.add(embed_model.encode([new_mem]).astype('float32'))
+        
+        torch.cuda.empty_cache()

llm.py

@@ -0,0 +1,23 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from langchain_community.llms import HuggingFacePipeline
+import torch
+
+def load_llm(model_path):
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        device_map="auto",
+        torch_dtype=torch.bfloat16,
+        trust_remote_code=True
+    )
+
+    pipe = pipeline(
+        "text-generation",
+        model=model,
+        tokenizer=tokenizer,
+        max_new_tokens=1024,
+        temperature=0.2,
+        repetition_penalty=1.15
+    )
+
+    return HuggingFacePipeline(pipeline=pipe)

memory_faiss.py

@@ -0,0 +1,28 @@
+import os
+import datetime
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_core.documents import Document
+
+FAISS_PATH = "data/faiss_index"
+
+def load_faiss():
+    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+    if os.path.exists(FAISS_PATH):
+        return FAISS.load_local(
+            FAISS_PATH,
+            embeddings,
+            allow_dangerous_deserialization=True
+        )
+    return FAISS.from_texts(
+        ["Initialisation mémoire Kibali"],
+        embeddings
+    )
+
+def save_memory(vectordb, user_msg, assistant_msg):
+    ts = datetime.datetime.now().isoformat()
+    vectordb.add_documents([
+        Document(page_content=f"[User {ts}] {user_msg}"),
+        Document(page_content=f"[Kibali {ts}] {assistant_msg}")
+    ])
+    vectordb.save_local(FAISS_PATH)

requirements.txt

@@ -0,0 +1,15 @@
+streamlit
+pandas
+folium
+streamlit-folium
+transformers
+sentence-transformers
+torch
+faiss-cpu
+numpy
+streamlit-js-eval
+tavily-python
+duckduckgo-search
+python-dotenv
+bitsandbytes
+accelerate

tools/geo.py

@@ -0,0 +1,34 @@
+# tools/geo.py
+import requests
+import logging
+
+def get_geo_context():
+    """
+    Récupère la géolocalisation par IP (Fallback gratuit et illimité).
+    """
+    try:
+        # Utilisation de ip-api.com (Gratuit, fiable, pas de clé requise)
+        response = requests.get('http://ip-api.com/json/', timeout=5)
+        data = response.json()
+        
+        if data.get('status') == 'success':
+            return {
+                "ip": data.get('query'),
+                "country": data.get('country', 'Gabon'),
+                "city": data.get('city', 'Libreville'),
+                "latitude": float(data.get('lat', 0.3908)),
+                "longitude": float(data.get('lon', 9.4544)),
+                "timezone": data.get('timezone', 'Africa/Libreville'),
+                "method": "IP (Approximatif)",
+                "lang": "Français"
+            }
+        else:
+            raise Exception("Erreur API ip-api")
+            
+    except Exception as e:
+        logging.warning(f"Échec IP Geo: {e}")
+        return {
+            "ip": "127.0.0.1", "country": "Gabon", "city": "Libreville",
+            "latitude": 0.3908, "longitude": 9.4544, "timezone": "Africa/Libreville",
+            "method": "Valeurs par défaut", "lang": "Français"
+        }

tools/local_docs.py

@@ -0,0 +1,23 @@
+from langchain.tools import Tool
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+import os
+
+EMBEDDINGS = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+INDEX_PATH = "memory/faiss_index"
+
+if os.path.exists(INDEX_PATH):
+    vectordb = FAISS.load_local(INDEX_PATH, EMBEDDINGS, allow_dangerous_deserialization=True)
+else:
+    vectordb = FAISS.from_texts(["Base vide"], EMBEDDINGS)
+    vectordb.save_local(INDEX_PATH)
+
+def local_search(query: str):
+    docs = vectordb.similarity_search(query, k=3)
+    return "\n".join([d.page_content for d in docs])
+
+local_knowledge_tool = Tool(
+    name="Base Locale",
+    func=local_search,
+    description="Recherche dans la base documentaire locale FAISS"
+)

tools/todo.py

@@ -0,0 +1,41 @@
+# tools/todo.py
+import streamlit as st
+import time
+
+def execute_reflection_plan(prompt, geo_info=None, messages=[]):
+    """
+    Phase de réflexion structurée avec verrouillage du sujet conversationnel.
+    """
+    if geo_info is None: geo_info = {}
+    
+    # 1. ANALYSE DU SUJET (Contextualisation)
+    # Si le prompt est court, on récupère le sujet du dernier message
+    subject = prompt
+    is_continuation = len(prompt.split()) < 5 or any(x in prompt.lower() for x in ["ils", "elles", "donc", "alors", "ceux-là"])
+    
+    if is_continuation and len(messages) > 0:
+        # On extrait le sujet principal du dernier échange pour "nourrir" la réflexion
+        subject = f"{prompt} (contexte: {messages[-1]['content'][:50]}...)"
+
+    location = f"{geo_info.get('city', 'Libreville')}, {geo_info.get('country', 'Gabon')}"
+    method = geo_info.get('method', 'Inconnue')
+
+    with st.status(f"🧠 Kibali Thinking Engine", expanded=True) as status:
+        st.write(f"🌍 **Localisation active :** {location}")
+        
+        if is_continuation:
+            st.write(f"🔗 **Liaison contextuelle :** Analyse du sujet précédent détectée.")
+        
+        steps = [
+            f"Identification de l'entité : Recherche d'informations sur '{subject}'.",
+            "Extraction de la mémoire sémantique FAISS pour éviter les répétitions.",
+            "Requête Web enrichie : Combinaison du sujet récent + question actuelle pour les images.",
+            f"Vérification de la pertinence culturelle et temporelle pour le Gabon."
+        ]
+        
+        for i, step in enumerate(steps):
+            st.write(f"{i+1}. {step}")
+            time.sleep(0.15)
+            
+        status.update(label="✅ Stratégie de réponse validée", state="complete", expanded=False)
+    return True

tools/web.py

@@ -0,0 +1,69 @@
+# tools/web.py
+from tavily import TavilyClient
+from duckduckgo_search import DDGS
+import streamlit as st
+import os
+from dotenv import load_dotenv
+
+# Chargement du fichier .env pour le local
+load_dotenv()
+
+# Récupération de la clé API (priorité au système/HF Secrets)
+TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
+
+def web_search(query: str):
+    """
+    Recherche hybride Tavily + DuckDuckGo avec sécurité API et fallback.
+    """
+    results = []
+    images = []
+    
+    # Initialisation client Tavily si la clé existe
+    tavily = None
+    if TAVILY_API_KEY:
+        tavily = TavilyClient(api_key=TAVILY_API_KEY)
+
+    # 1. TENTATIVE AVEC TAVILY
+    if tavily:
+        try:
+            res = tavily.search(
+                query=query, 
+                max_results=5, 
+                search_depth="advanced",
+                include_images=True
+            )
+            results = res.get('results', [])
+            images = res.get('images', [])
+            
+            if len(results) >= 3:
+                return {"results": results, "images": images, "query": query, "source": "Tavily"}
+                
+        except Exception as e:
+            st.warning("🔄 Tavily indisponible ou limite atteinte, basculement sur DuckDuckGo...")
+
+    # 2. FALLBACK AVEC DUCKDUCKGO
+    try:
+        with DDGS() as ddgs:
+            # Texte
+            ddg_text = list(ddgs.text(query, max_results=5))
+            for r in ddg_text:
+                results.append({
+                    "title": r.get('title'),
+                    "content": r.get('body'),
+                    "url": r.get('href')
+                })
+            
+            # Images
+            if not images:
+                ddg_imgs = list(ddgs.images(query, max_results=3))
+                images = [img.get('image') for img in ddg_imgs]
+                
+    except Exception as e:
+        st.error(f"⚠️ Échec critique des moteurs de recherche : {e}")
+
+    return {
+        "results": results,
+        "images": images, 
+        "query": query,
+        "source": "Hybrid/DDG"
+    }