Bóg wie co z tego bedzie

backend/app/api/factcheck_router.py

@@ -0,0 +1,57 @@
+from fastapi import APIRouter, HTTPException
+from app.models.factcheck_schemas import FactCheckRequest, FactCheckResponse, FactCheckSource
+from app.services.factcheck_service import search_web, analyze_with_gemini
+
+router = APIRouter()
+
+@router.post(
+    "/factcheck", 
+    response_model=FactCheckResponse, 
+    tags=["Fact-checking"],
+    summary="Zweryfikuj prawdziwość stwierdzenia"
+)
+async def fact_check_endpoint(payload: FactCheckRequest):
+    statement = payload.statement.strip()
+    if len(statement) < 10:
+        raise HTTPException(status_code=400, detail="Tekst do weryfikacji musi mieć co najmniej 10 znaków.")
+
+    # 1. Przeszukiwanie sieci
+    web_results = search_web(statement, max_results=5)
+    if not web_results:
+        return FactCheckResponse(
+            verdict="SPORNE",
+            explanation="Wyszukiwarka nie zwróciła żadnych wyników w internecie dla tego stwierdzenia, co uniemożliwia weryfikację.",
+            confidence=0.0,
+            sources=[]
+        )
+
+    # 2. Analiza przez LLM
+    analysis = await analyze_with_gemini(statement, web_results)
+
+    # 3. Przypisanie źródeł na podstawie decyzji LLM
+    used_indices = analysis.get("sources_used_indices", [])
+    used_sources = []
+    
+    for idx in used_indices:
+        source_idx = idx - 1  # Korekta indeksu (model liczy od 1)
+        if 0 <= source_idx < len(web_results):
+            r = web_results[source_idx]
+            used_sources.append(FactCheckSource(
+                title=r["title"],
+                url=r["url"],
+                snippet=r["snippet"]
+            ))
+
+    # Jeśli model nie wskazał konkretnych indeksów, dajemy top 3 znalezione źródła
+    if not used_sources:
+        used_sources = [
+            FactCheckSource(title=r["title"], url=r["url"], snippet=r["snippet"])
+            for r in web_results[:3]
+        ]
+
+    return FactCheckResponse(
+        verdict=analysis.get("verdict", "SPORNE"),
+        explanation=analysis.get("explanation", "Brak szczegółowego uzasadnienia."),
+        confidence=analysis.get("confidence", 0.5),
+        sources=used_sources
+    )

backend/app/api/routes.py

@@ -154,4 +154,7 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
         analysis_time=analysis_result["analysis_time"],
         used_model=model,
         content_type=content_type,
-    )
+    )
+
+from app.api.factcheck_router import router as factcheck_router
+router.include_router(factcheck_router) #kupczak tu był 

backend/app/models/factcheck_schemas.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import List
+
+class FactCheckRequest(BaseModel):
+    statement: str
+
+class FactCheckSource(BaseModel):
+    title: str
+    url: str
+    snippet: str
+
+class FactCheckResponse(BaseModel):
+    verdict: str  # "PRAWDA", "FAŁSZ", "SPORNE"
+    explanation: str
+    confidence: float
+    sources: List[FactCheckSource]

backend/app/services/factcheck_service.py

@@ -0,0 +1,100 @@
+import logging
+import json
+import re
+import os
+from typing import Dict, Any, List
+from duckduckgo_search import DDGS
+import google.generativeai as genai
+
+logger = logging.getLogger(__name__)
+
+def search_web(query: str, max_results: int = 5) -> List[Dict[str, str]]:
+    """Przeszukuje internet bez limitów i bez kluczy API za pomocą DuckDuckGo."""
+    logger.info(f"Wyszukiwanie w sieci dla zapytania: {query}")
+    try:
+        with DDGS() as ddgs:
+            results = ddgs.text(query, max_results=max_results)
+            formatted_results = []
+            for r in results:
+                formatted_results.append({
+                    "title": r.get("title", "Brak tytułu"),
+                    "url": r.get("href", ""),
+                    "snippet": r.get("body", "Brak opisu")
+                })
+            return formatted_results
+    except Exception as e:
+        logger.error(f"Błąd wyszukiwania DuckDuckGo: {e}", exc_info=True)
+        return []
+
+async def analyze_with_gemini(statement: str, sources: List[Dict[str, str]]) -> Dict[str, Any]:
+    """Analizuje stwierdzenie na podstawie wyników wyszukiwania za pomocą Gemini API."""
+    # Pobieramy klucz bezpośrednio ze środowiska lub .env
+    api_key = os.getenv("GEMINI_API_KEY")
+    
+    if not api_key:
+        logger.error("Brak klucza GEMINI_API_KEY w środowisku systemowym!")
+        return {
+            "verdict": "SPORNE",
+            "explanation": "Błąd backendu: Brak skonfigurowanego klucza GEMINI_API_KEY w pliku .env.",
+            "confidence": 0.0,
+            "sources_used_indices": []
+        }
+        
+    genai.configure(api_key=api_key)
+    
+    # Przygotowanie czytelnego tekstu ze źródłami dla LLM
+    sources_text = ""
+    for idx, s in enumerate(sources, start=1):
+        sources_text += f"[{idx}] Tytuł: {s['title']}\nURL: {s['url']}\nTreść: {s['snippet']}\n\n"
+        
+    prompt = f"""Jesteś zaawansowanym asystentem do weryfikacji faktów (fact-checking).
+Twoim zadaniem jest ocena, czy podane STWIERDZENIE jest prawdziwe, fałszywe czy sporne na podstawie dostarczonych WYNIKÓW WYSZUKIWANIA.
+
+STWIERDZENIE DO WERYFIKACJI:
+"{statement}"
+
+WYNIKI WYSZUKIWANIA:
+{sources_text}
+
+Wygeneruj rzetelną analizę. Odpowiedz w języku polskim. Twoja odpowiedź MUSI być poprawnym, czystym obiektem JSON o następującym formacie (i niczym innym):
+{{
+  "verdict": "PRAWDA" lub "FAŁSZ" lub "SPORNE",
+  "explanation": "Zwięzłe (2-4 zdania), merytoryczne i obiektywne uzasadnienie werdyktu w języku polskim wraz z odniesieniem do źródeł.",
+  "confidence": 0.85,
+  "sources_used_indices": [1, 3]
+}}
+
+Zasady oceny:
+- "PRAWDA": Wyniki jednoznacznie potwierdzają to stwierdzenie.
+- "FAŁSZ": Wyniki wykazują błąd, dezinformację lub bezpośrednio zaprzeczają stwierdzeniu.
+- "SPORNE": Istnieją sprzeczne informacje, jest to kwestia opinii lub źródła nie dają jednoznacznej odpowiedzi.
+
+Zwróć TYLKO czysty obiekt JSON. Nie dodawaj bloków kodu ```json ani żadnych komentarzy poza obiektem JSON."""
+
+    try:
+        model = genai.GenerativeModel("gemini-1.5-flash")
+        response = model.generate_content(
+            prompt,
+            generation_config=genai.types.GenerationConfig(
+                temperature=0.0,  # Niska temperatura chroni przed zmyślaniem (hallucination)
+                response_mime_type="application/json"
+            )
+        )
+        
+        raw_text = response.text.strip()
+        
+        # Oczyszczenie formatowania markdown, gdyby model mimo wszystko go dodał
+        if raw_text.startswith("```"):
+            match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", raw_text, re.DOTALL)
+            if match:
+                raw_text = match.group(1)
+                
+        return json.loads(raw_text)
+    except Exception as e:
+        logger.error(f"Błąd analizy Gemini API: {e}", exc_info=True)
+        return {
+            "verdict": "SPORNE",
+            "explanation": f"Wystąpił błąd komunikacji z modelem językowym: {str(e)}",
+            "confidence": 0.0,
+            "sources_used_indices": []
+        }

backend/requirements.txt

@@ -12,4 +12,6 @@ protobuf
 Pillow
 slowapi
 pytest==7.4.3
-pytest-asyncio==0.21.1
+pytest-asyncio==0.21.1
+duckduckgo-search>=6.0.0
+google-generativeai>=0.8.0

index.js

@@ -53,6 +53,10 @@ client.once(Events.ClientReady, async () => {
 			{
 				name: "Wykryj deepfake",
 				type: ApplicationCommandType.Message
+			},
+			{
+				name: "Weryfikacja faktów", // <--- TA LINIA
+				type: ApplicationCommandType.Message
 			}
 		]);
 		console.log("Pomyślnie zarejestrowano komendy (/detect, /setup oraz menu kontekstowe)");
@@ -306,6 +310,8 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 	}
 }
 
+//funkcja kupczaka
+
 client.on(Events.InteractionCreate, async (interaction) => {
 	
 	if (interaction.isChatInputCommand()) {
@@ -410,8 +416,23 @@ client.on(Events.InteractionCreate, async (interaction) => {
 
 			await handleAnalysis(interaction, contentToAnalyze, targetMessage, explicitContentType);
 		}
-	}
+					if (interaction.commandName === "Weryfikacja faktów") {
+			const targetMessage = interaction.targetMessage;
+			const contentToVerify = targetMessage.content;
 
+			if (!contentToVerify || contentToVerify.trim().length < 10) {
+				return interaction.reply({
+					content: "❌ Wiadomość musi mieć przynajmniej 10 znaków tekstu, aby można było ją zweryfikować.",
+					flags: [MessageFlags.Ephemeral]
+				});
+			}
+
+			await handleFactCheck(interaction, contentToVerify);
+		}
+	
+	}
+	//koniec funkcji kupczaka
+	
 	if (interaction.isModalSubmit()) {
 		if (interaction.customId === "detectModal") {
 			const userContent = interaction.fields.getTextInputValue("detectInput");