Add LLM optimizer tab with iterative constrained text improvements

Introduce an OpenAI-compatible optimizer workflow with user-provided API key, local sentence-level edits, per-iteration rescoring, and before/after metric tracking in a dedicated UI tab.

Made-with: Cursor

app.py

@@ -17,6 +17,8 @@ from models import (
     UrlFetchRequest,
     UrlFetchResponse,
     UserAgentsResponse,
+    OptimizerRequest,
+    OptimizerResponse,
 )
 import logic
 import nlp_processor
@@ -25,6 +27,7 @@ import highlighter
 import summarizer
 import search
 import url_fetcher
+import optimizer
 
 app = FastAPI(title="SEO AI Editor MVP")
 
@@ -246,6 +249,15 @@ async def fetch_url_endpoint(request: UrlFetchRequest):
             error=str(e),
         )
 
+
+@app.post("/api/v1/optimizer/run", response_model=OptimizerResponse)
+async def run_optimizer(request: OptimizerRequest):
+    try:
+        result = optimizer.optimize_text(request.model_dump())
+        return OptimizerResponse(**result)
+    except Exception as e:
+        return OptimizerResponse(ok=False, error=str(e))
+
 # Hugging Face Spaces использует порт 7860
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))

models.py

@@ -72,4 +72,31 @@ class UserAgentInfo(BaseModel):
 
 
 class UserAgentsResponse(BaseModel):
-    user_agents: List[UserAgentInfo] = Field(default_factory=list)
+    user_agents: List[UserAgentInfo] = Field(default_factory=list)
+
+
+class OptimizerRequest(BaseModel):
+    target_text: str
+    competitors: List[str] = Field(default_factory=list)
+    keywords: List[str] = Field(default_factory=list)
+    language: str = "en"
+    target_title: str = ""
+    competitor_titles: List[str] = Field(default_factory=list)
+
+    api_key: str
+    api_base_url: str = "https://api.deepseek.com/v1"
+    model: str = "deepseek-chat"
+
+    max_iterations: int = 2
+    candidates_per_iteration: int = 2
+    temperature: float = 0.25
+
+
+class OptimizerResponse(BaseModel):
+    ok: bool = True
+    optimized_text: str = ""
+    baseline_metrics: Dict[str, Any] = Field(default_factory=dict)
+    final_metrics: Dict[str, Any] = Field(default_factory=dict)
+    iterations: List[Dict[str, Any]] = Field(default_factory=list)
+    applied_changes: int = 0
+    error: str = ""

optimizer.py

@@ -0,0 +1,538 @@
+import json
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+import requests
+
+import logic
+import nlp_processor
+import semantic_graph
+
+
+STOP_WORDS = {
+    "en": {"a", "an", "and", "or", "the", "to", "of", "for", "in", "on", "at", "by", "with", "from", "as", "is", "are", "be", "was", "were"},
+    "ru": {"и", "или", "в", "во", "на", "по", "с", "со", "к", "ко", "для", "из", "за", "что", "это", "как", "а", "но", "у", "о", "от"},
+    "de": {"und", "oder", "der", "die", "das", "zu", "von", "mit", "fur", "in", "auf", "ist", "sind"},
+    "es": {"y", "o", "el", "la", "los", "las", "de", "del", "en", "con", "para", "por", "es", "son"},
+    "it": {"e", "o", "il", "lo", "la", "i", "gli", "le", "di", "del", "in", "con", "per", "da", "e", "sono"},
+    "pl": {"i", "oraz", "lub", "w", "na", "z", "ze", "do", "od", "po", "dla", "to", "jest", "sa"},
+    "pt": {"e", "ou", "o", "a", "os", "as", "de", "do", "da", "em", "no", "na", "com", "para", "por", "e", "sao"},
+}
+
+
+def _tokenize(text: str) -> List[str]:
+    return [
+        x
+        for x in re.sub(r"[^\w\s-]+", " ", (text or "").lower(), flags=re.UNICODE).split()
+        if len(x) >= 2
+    ]
+
+
+def _filter_stopwords(tokens: List[str], language: str) -> List[str]:
+    stop = STOP_WORDS.get(language, STOP_WORDS["en"])
+    return [t for t in tokens if t not in stop]
+
+
+def _split_sentences(text: str) -> List[str]:
+    text = (text or "").strip()
+    if not text:
+        return []
+    parts = re.split(r"(?<=[\.\!\?])\s+", text)
+    parts = [p.strip() for p in parts if p.strip()]
+    if len(parts) <= 1:
+        parts = [p.strip() for p in re.split(r"\n+", text) if p.strip()]
+    return parts
+
+
+def _build_analysis_snapshot(
+    target_text: str,
+    competitors: List[str],
+    keywords: List[str],
+    language: str,
+    target_title: str,
+    competitor_titles: List[str],
+) -> Dict[str, Any]:
+    wc_target = logic.count_words(target_text, language)
+    wc_comp = [logic.count_words(t, language) for t in competitors]
+    if wc_comp:
+        avg_total = sum(c["total"] for c in wc_comp) / len(wc_comp)
+        avg_sig = sum(c["significant"] for c in wc_comp) / len(wc_comp)
+    else:
+        avg_total = 0
+        avg_sig = 0
+
+    ngram_stats = logic.calculate_ngram_stats(target_text, competitors, language)
+    key_phrases, _ = logic.parse_keywords(keywords, language)
+    bm25 = logic.calculate_bm25_recommendations(target_text, competitors, keywords, language)
+    bert = logic.perform_bert_analysis(target_text, competitors, key_phrases, language)
+
+    title_data = {}
+    if (target_title or "").strip():
+        title_data = logic.analyze_title(target_title, competitor_titles, keywords, language)
+
+    return {
+        "word_counts": {
+            "target": wc_target,
+            "competitors": wc_comp,
+            "avg": {"total": round(avg_total), "significant": round(avg_sig)},
+        },
+        "ngram_stats": ngram_stats,
+        "bm25_recommendations": bm25,
+        "bert_analysis": bert,
+        "title_analysis": title_data,
+    }
+
+
+def _build_semantic_snapshot(
+    target_text: str,
+    competitors: List[str],
+    language: str,
+) -> Dict[str, Any]:
+    def _build_doc(text: str, doc_id: int) -> Dict[str, Any]:
+        sentences_data = nlp_processor.preprocess_text(text, language)
+        graph, word_weights = semantic_graph.build_semantic_graph(sentences_data, lang=language)
+        graph_data = semantic_graph.get_graph_data_for_frontend(graph)
+        return {
+            "id": doc_id,
+            "text": text,
+            "word_weights": word_weights,
+            "stats": {
+                "nodes": len(graph_data.get("nodes", [])),
+                "links": len(graph_data.get("links", [])),
+            },
+        }
+
+    target_doc = _build_doc(target_text, 0)
+    comp_docs = []
+    for idx, c in enumerate([x for x in competitors if (x or "").strip()]):
+        comp_docs.append(_build_doc(c, idx + 1))
+
+    num_comp = len(comp_docs)
+    target_weights = target_doc["word_weights"]
+    all_terms = set(target_weights.keys())
+    for c in comp_docs:
+        all_terms.update(c["word_weights"].keys())
+
+    term_power_table = []
+    for term in all_terms:
+        target_weight = int(target_weights.get(term, 0))
+        comp_weights = [int(c["word_weights"].get(term, 0)) for c in comp_docs]
+        comp_avg = round(sum(comp_weights) / max(1, num_comp), 2)
+        comp_occ = sum(1 for w in comp_weights if w > 0)
+        term_power_table.append(
+            {
+                "term": term,
+                "target_weight": target_weight,
+                "competitor_avg_weight": comp_avg,
+                "comp_occurrence": comp_occ,
+                "comp_total": num_comp,
+            }
+        )
+    return {"comparison": {"term_power_table": term_power_table, "num_competitors": num_comp}}
+
+
+def _compute_metrics(analysis: Dict[str, Any], semantic: Dict[str, Any], keywords: List[str], language: str) -> Dict[str, Any]:
+    competitor_count = len(analysis.get("word_counts", {}).get("competitors", []))
+    min_signal = 1 if competitor_count <= 1 else 2
+
+    bert_details = analysis.get("bert_analysis", {}).get("detailed", []) or []
+    bert_low = [d for d in bert_details if float(d.get("my_max_score", 0)) < 0.7]
+
+    bm25_remove = [x for x in (analysis.get("bm25_recommendations") or []) if x.get("action") == "remove"]
+    bm25_remove_count = len(bm25_remove)
+
+    ngram_signal_count = 0
+    ngrams = analysis.get("ngram_stats", {}) or {}
+    for bucket_name in ("unigrams", "bigrams"):
+        for item in (ngrams.get(bucket_name) or []):
+            comp_occ = int(item.get("comp_occurrence", 0))
+            if comp_occ < min_signal:
+                continue
+            target = float(item.get("target_count", 0))
+            comp_avg = float(item.get("competitor_avg", 0))
+            ratio_signal = comp_avg > 0 if target == 0 else comp_avg >= target * 2
+            if ratio_signal:
+                ngram_signal_count += 1
+
+    title_score = None
+    title_bert = analysis.get("title_analysis", {}).get("bert", {})
+    if title_bert and title_bert.get("target_score") is not None:
+        title_score = float(title_bert.get("target_score", 0))
+
+    keyword_terms = set()
+    for kw in keywords:
+        tokens = _filter_stopwords(_tokenize(kw), language)
+        for t in tokens:
+            keyword_terms.add(t)
+        for n in (2, 3):
+            for i in range(0, max(0, len(tokens) - n + 1)):
+                keyword_terms.add(" ".join(tokens[i : i + n]))
+
+    table = semantic.get("comparison", {}).get("term_power_table", []) or []
+    by_term = {str(r.get("term", "")).lower(): r for r in table}
+    semantic_gap_count = 0
+    for term in keyword_terms:
+        row = by_term.get(term)
+        if not row:
+            continue
+        gap = float(row.get("competitor_avg_weight", 0)) - float(row.get("target_weight", 0))
+        if gap > 0 and int(row.get("comp_occurrence", 0)) >= min_signal:
+            semantic_gap_count += 1
+
+    # Composite score (0..100)
+    w_bert, w_bm25, w_ng, w_title, w_sem = 30, 20, 15, 10, 25
+    bert_comp = 1.0 - (len(bert_low) / max(1, len(bert_details)))
+    bm25_comp = 1.0 if bm25_remove_count <= 3 else max(0.0, 1.0 - ((bm25_remove_count - 3) / 10.0))
+    ng_comp = max(0.0, 1.0 - (ngram_signal_count / 15.0))
+    title_comp = 1.0 if title_score is None else min(1.0, max(0.0, title_score / 0.65))
+    sem_comp = max(0.0, 1.0 - (semantic_gap_count / 20.0))
+
+    weighted = (
+        w_bert * bert_comp
+        + w_bm25 * bm25_comp
+        + w_ng * ng_comp
+        + w_title * title_comp
+        + w_sem * sem_comp
+    )
+    total_w = w_bert + w_bm25 + w_ng + w_title + w_sem
+    score = round((weighted / total_w) * 100.0, 2)
+
+    return {
+        "score": score,
+        "competitor_count": competitor_count,
+        "min_competitor_signal": min_signal,
+        "bert_low_count": len(bert_low),
+        "bert_total_keywords": len(bert_details),
+        "bm25_remove_count": bm25_remove_count,
+        "ngram_signal_count": ngram_signal_count,
+        "title_bert_score": title_score,
+        "semantic_gap_count": semantic_gap_count,
+    }
+
+
+def _choose_optimization_goal(analysis: Dict[str, Any], semantic: Dict[str, Any], keywords: List[str], language: str) -> Dict[str, Any]:
+    bert_details = analysis.get("bert_analysis", {}).get("detailed", []) or []
+    low_bert = [x for x in bert_details if float(x.get("my_max_score", 0)) < 0.7]
+    if low_bert:
+        worst = sorted(low_bert, key=lambda x: float(x.get("my_max_score", 0)))[0]
+        focus_terms = _filter_stopwords(_tokenize(worst.get("phrase", "")), language)[:4]
+        return {"type": "bert", "label": str(worst.get("phrase", "")), "focus_terms": focus_terms, "avoid_terms": []}
+
+    bm25_remove = [x for x in (analysis.get("bm25_recommendations") or []) if x.get("action") == "remove"]
+    if len(bm25_remove) >= 4:
+        spam_terms = [str(x.get("word", "")) for x in sorted(bm25_remove, key=lambda r: int(r.get("count", 0)), reverse=True)[:4]]
+        return {"type": "bm25", "label": "reduce spam", "focus_terms": [], "avoid_terms": spam_terms}
+
+    # Semantic keyword gaps
+    lang_stop = STOP_WORDS.get(language, STOP_WORDS["en"])
+    keyword_terms = set()
+    for kw in keywords:
+        toks = [t for t in _tokenize(kw) if t not in lang_stop]
+        keyword_terms.update(toks)
+        for n in (2, 3):
+            for i in range(0, max(0, len(toks) - n + 1)):
+                keyword_terms.add(" ".join(toks[i : i + n]))
+    table = semantic.get("comparison", {}).get("term_power_table", []) or []
+    candidate_rows: List[Tuple[str, float]] = []
+    for row in table:
+        term = str(row.get("term", "")).lower()
+        if term not in keyword_terms:
+            continue
+        gap = float(row.get("competitor_avg_weight", 0)) - float(row.get("target_weight", 0))
+        if gap > 0:
+            candidate_rows.append((term, gap))
+    if candidate_rows:
+        top_term = sorted(candidate_rows, key=lambda x: x[1], reverse=True)[0][0]
+        return {"type": "semantic", "label": top_term, "focus_terms": [top_term], "avoid_terms": []}
+
+    # Fallback: ngram add signal
+    for bucket_name in ("unigrams", "bigrams"):
+        bucket = analysis.get("ngram_stats", {}).get(bucket_name, []) or []
+        for item in bucket:
+            target = float(item.get("target_count", 0))
+            comp_avg = float(item.get("competitor_avg", 0))
+            if (target == 0 and comp_avg > 0) or (target > 0 and comp_avg >= target * 2):
+                return {"type": "ngram", "label": str(item.get("ngram", "")), "focus_terms": _tokenize(str(item.get("ngram", "")))[:3], "avoid_terms": []}
+
+    return {"type": "none", "label": "no-op", "focus_terms": [], "avoid_terms": []}
+
+
+def _choose_sentence_idx(sentences: List[str], focus_terms: List[str], avoid_terms: List[str], language: str) -> int:
+    if not sentences:
+        return 0
+    stop = STOP_WORDS.get(language, STOP_WORDS["en"])
+    focus = [x for x in focus_terms if x and x not in stop]
+
+    if avoid_terms:
+        best_idx, best_score = 0, -1.0
+        for i, s in enumerate(sentences):
+            lower = s.lower()
+            score = sum(lower.count(t.lower()) for t in avoid_terms if t)
+            if score > best_score:
+                best_idx, best_score = i, score
+        return best_idx
+
+    if focus:
+        best_idx, best_score = 0, -1.0
+        for i, s in enumerate(sentences):
+            lower = s.lower()
+            score = sum(lower.count(t.lower()) for t in focus)
+            if score > best_score:
+                best_idx, best_score = i, score
+        return best_idx
+
+    return min(2, len(sentences) - 1)
+
+
+def _extract_json_object(text: str) -> Optional[Dict[str, Any]]:
+    raw = (text or "").strip()
+    if not raw:
+        return None
+    try:
+        return json.loads(raw)
+    except Exception:
+        pass
+    m = re.search(r"\{[\s\S]*\}", raw)
+    if not m:
+        return None
+    try:
+        return json.loads(m.group(0))
+    except Exception:
+        return None
+
+
+def _llm_rewrite_sentence(
+    *,
+    api_key: str,
+    base_url: str,
+    model: str,
+    language: str,
+    full_text: str,
+    original_sentence: str,
+    goal_type: str,
+    goal_label: str,
+    focus_terms: List[str],
+    avoid_terms: List[str],
+    temperature: float,
+) -> str:
+    endpoint = base_url.rstrip("/") + "/chat/completions"
+    system_msg = (
+        "You are an SEO copy editor. Edit only one sentence while preserving narrative flow, factual tone, and language. "
+        "Return strict JSON only: {\"revised_sentence\": \"...\"}. "
+        "Do not rewrite the whole text."
+    )
+    user_msg = (
+        f"Language: {language}\n"
+        f"Goal: {goal_type} ({goal_label})\n"
+        f"Must preserve overall narrative and style.\n"
+        f"Focus terms to strengthen: {', '.join(focus_terms) if focus_terms else '-'}\n"
+        f"Terms to de-emphasize/avoid overuse: {', '.join(avoid_terms) if avoid_terms else '-'}\n\n"
+        f"Original sentence:\n{original_sentence}\n\n"
+        f"Context text:\n{full_text[:6000]}\n\n"
+        "Constraints:\n"
+        "1) Keep sentence length reasonable.\n"
+        "2) Keep local coherence with surrounding text.\n"
+        "3) Only output JSON object."
+    )
+    payload = {
+        "model": model,
+        "temperature": float(max(0.0, min(1.2, temperature))),
+        "messages": [
+            {"role": "system", "content": system_msg},
+            {"role": "user", "content": user_msg},
+        ],
+        "response_format": {"type": "json_object"},
+    }
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    response = requests.post(endpoint, headers=headers, json=payload, timeout=60)
+    response.raise_for_status()
+    data = response.json()
+    content = (
+        data.get("choices", [{}])[0]
+        .get("message", {})
+        .get("content", "")
+    )
+    parsed = _extract_json_object(content)
+    if not parsed or not str(parsed.get("revised_sentence", "")).strip():
+        raise ValueError("LLM returned invalid JSON edit payload.")
+    return str(parsed["revised_sentence"]).strip()
+
+
+def _is_candidate_valid(prev_metrics: Dict[str, Any], next_metrics: Dict[str, Any]) -> bool:
+    if next_metrics["bert_low_count"] > prev_metrics["bert_low_count"]:
+        return False
+    if next_metrics["bm25_remove_count"] > prev_metrics["bm25_remove_count"]:
+        return False
+    if next_metrics["semantic_gap_count"] > prev_metrics["semantic_gap_count"]:
+        return False
+    prev_title = prev_metrics.get("title_bert_score")
+    next_title = next_metrics.get("title_bert_score")
+    if prev_title is not None and next_title is not None and next_title < (prev_title - 0.03):
+        return False
+    return True
+
+
+def optimize_text(request_data: Dict[str, Any]) -> Dict[str, Any]:
+    target_text = str(request_data.get("target_text", "")).strip()
+    competitors = [str(x) for x in (request_data.get("competitors") or []) if str(x).strip()]
+    keywords = [str(x) for x in (request_data.get("keywords") or []) if str(x).strip()]
+    language = str(request_data.get("language", "en")).strip() or "en"
+    target_title = str(request_data.get("target_title", "") or "")
+    competitor_titles = [str(x) for x in (request_data.get("competitor_titles") or [])]
+
+    api_key = str(request_data.get("api_key", "")).strip()
+    if not api_key:
+        raise ValueError("API key is required.")
+    base_url = str(request_data.get("api_base_url", "https://api.deepseek.com/v1")).strip() or "https://api.deepseek.com/v1"
+    model = str(request_data.get("model", "deepseek-chat")).strip() or "deepseek-chat"
+    max_iterations = int(request_data.get("max_iterations", 2) or 2)
+    max_iterations = max(1, min(8, max_iterations))
+    candidates_per_iteration = int(request_data.get("candidates_per_iteration", 2) or 2)
+    candidates_per_iteration = max(1, min(5, candidates_per_iteration))
+    temperature = float(request_data.get("temperature", 0.25) or 0.25)
+
+    baseline_analysis = _build_analysis_snapshot(
+        target_text, competitors, keywords, language, target_title, competitor_titles
+    )
+    baseline_semantic = _build_semantic_snapshot(target_text, competitors, language)
+    baseline_metrics = _compute_metrics(baseline_analysis, baseline_semantic, keywords, language)
+
+    current_text = target_text
+    current_analysis = baseline_analysis
+    current_semantic = baseline_semantic
+    current_metrics = baseline_metrics
+    logs: List[Dict[str, Any]] = []
+    applied_changes = 0
+
+    for step in range(max_iterations):
+        goal = _choose_optimization_goal(current_analysis, current_semantic, keywords, language)
+        if goal["type"] == "none":
+            logs.append({"step": step + 1, "status": "stopped", "reason": "No optimization goals left."})
+            break
+
+        sentences = _split_sentences(current_text)
+        if not sentences:
+            logs.append({"step": step + 1, "status": "stopped", "reason": "No sentences available for editing."})
+            break
+
+        sent_idx = _choose_sentence_idx(sentences, goal["focus_terms"], goal["avoid_terms"], language)
+        original_sentence = sentences[sent_idx]
+        candidates = []
+
+        for ci in range(candidates_per_iteration):
+            temp = min(1.1, max(0.0, temperature + ci * 0.1))
+            try:
+                revised_sentence = _llm_rewrite_sentence(
+                    api_key=api_key,
+                    base_url=base_url,
+                    model=model,
+                    language=language,
+                    full_text=current_text,
+                    original_sentence=original_sentence,
+                    goal_type=goal["type"],
+                    goal_label=goal["label"],
+                    focus_terms=goal["focus_terms"],
+                    avoid_terms=goal["avoid_terms"],
+                    temperature=temp,
+                )
+                if not revised_sentence or revised_sentence == original_sentence:
+                    continue
+
+                candidate_sentences = sentences[:]
+                candidate_sentences[sent_idx] = revised_sentence
+                candidate_text = " ".join(candidate_sentences).strip()
+
+                cand_analysis = _build_analysis_snapshot(
+                    candidate_text, competitors, keywords, language, target_title, competitor_titles
+                )
+                cand_semantic = _build_semantic_snapshot(candidate_text, competitors, language)
+                cand_metrics = _compute_metrics(cand_analysis, cand_semantic, keywords, language)
+                valid = _is_candidate_valid(current_metrics, cand_metrics)
+                delta_score = round(cand_metrics["score"] - current_metrics["score"], 3)
+                candidates.append(
+                    {
+                        "candidate_index": ci + 1,
+                        "sentence_after": revised_sentence,
+                        "text": candidate_text,
+                        "analysis": cand_analysis,
+                        "semantic": cand_semantic,
+                        "metrics": cand_metrics,
+                        "valid": valid,
+                        "delta_score": delta_score,
+                    }
+                )
+            except Exception as e:
+                candidates.append(
+                    {
+                        "candidate_index": ci + 1,
+                        "error": str(e),
+                        "valid": False,
+                        "delta_score": -999.0,
+                    }
+                )
+
+        valid_candidates = [c for c in candidates if c.get("valid")]
+        if not valid_candidates:
+            logs.append(
+                {
+                    "step": step + 1,
+                    "status": "rejected",
+                    "goal": goal,
+                    "sentence_before": original_sentence,
+                    "reason": "No valid candidate satisfied constraints.",
+                    "candidates": [
+                        {
+                            "candidate_index": c.get("candidate_index"),
+                            "valid": c.get("valid", False),
+                            "delta_score": c.get("delta_score"),
+                            "error": c.get("error"),
+                        }
+                        for c in candidates
+                    ],
+                }
+            )
+            break
+
+        best = sorted(valid_candidates, key=lambda c: c["metrics"]["score"], reverse=True)[0]
+        if best["metrics"]["score"] <= current_metrics["score"]:
+            logs.append(
+                {
+                    "step": step + 1,
+                    "status": "rejected",
+                    "goal": goal,
+                    "sentence_before": original_sentence,
+                    "reason": "Best valid candidate did not improve total score.",
+                    "best_candidate_score": best["metrics"]["score"],
+                    "current_score": current_metrics["score"],
+                }
+            )
+            break
+
+        prev_metrics = current_metrics
+        current_text = best["text"]
+        current_analysis = best["analysis"]
+        current_semantic = best["semantic"]
+        current_metrics = best["metrics"]
+        applied_changes += 1
+
+        logs.append(
+            {
+                "step": step + 1,
+                "status": "applied",
+                "goal": goal,
+                "sentence_before": original_sentence,
+                "sentence_after": best["sentence_after"],
+                "metrics_before": prev_metrics,
+                "metrics_after": current_metrics,
+                "delta_score": round(current_metrics["score"] - prev_metrics["score"], 3),
+            }
+        )
+
+    return {
+        "ok": True,
+        "optimized_text": current_text,
+        "baseline_metrics": baseline_metrics,
+        "final_metrics": current_metrics,
+        "iterations": logs,
+        "applied_changes": applied_changes,
+    }

templates/index.html

@@ -146,6 +146,9 @@
                 <li class="nav-item">
                     <button class="nav-link" id="summary-tab" data-bs-toggle="tab" data-bs-target="#summaryPane" type="button">✅ Сводка</button>
                 </li>
+                <li class="nav-item">
+                    <button class="nav-link" id="optimizer-tab" data-bs-toggle="tab" data-bs-target="#optimizerPane" type="button">🤖 LLM Optimizer</button>
+                </li>
             </ul>
 
             <div class="tab-content" id="resultsContent">
@@ -270,6 +273,47 @@
                     </div>
                 </div>
 
+                <!-- OPTIMIZER TAB -->
+                <div class="tab-pane fade" id="optimizerPane" role="tabpanel">
+                    <div class="stat-card">
+                        <h5 class="card-title mb-3">LLM Optimizer (итеративная доработка текста)</h5>
+                        <div class="row g-2">
+                            <div class="col-md-6">
+                                <label class="form-label small text-muted mb-1">API Key (пользовательский)</label>
+                                <input type="password" id="optimizerApiKey" class="form-control" placeholder="sk-...">
+                            </div>
+                            <div class="col-md-6">
+                                <label class="form-label small text-muted mb-1">Base URL (OpenAI-compatible)</label>
+                                <input type="text" id="optimizerBaseUrl" class="form-control" value="https://api.deepseek.com/v1">
+                            </div>
+                            <div class="col-md-4">
+                                <label class="form-label small text-muted mb-1">Model</label>
+                                <input type="text" id="optimizerModel" class="form-control" value="deepseek-chat">
+                            </div>
+                            <div class="col-md-3">
+                                <label class="form-label small text-muted mb-1">Итерации</label>
+                                <input type="number" id="optimizerIterations" class="form-control" min="1" max="8" value="2">
+                            </div>
+                            <div class="col-md-3">
+                                <label class="form-label small text-muted mb-1">Кандидатов/шаг</label>
+                                <input type="number" id="optimizerCandidates" class="form-control" min="1" max="5" value="2">
+                            </div>
+                            <div class="col-md-2">
+                                <label class="form-label small text-muted mb-1">Temp</label>
+                                <input type="number" id="optimizerTemp" class="form-control" min="0" max="1.2" step="0.05" value="0.25">
+                            </div>
+                        </div>
+                        <div class="d-flex gap-2 mt-3">
+                            <button class="btn btn-dark" onclick="runLlmOptimization()">Запустить оптимизацию</button>
+                            <button class="btn btn-outline-secondary" onclick="applyOptimizedText()">Применить в Target</button>
+                        </div>
+                        <p class="small text-muted mt-2 mb-0">API key не сохраняется в проект и используется только для текущего запроса.</p>
+                    </div>
+                    <div id="optimizerResultsContainer">
+                        <div class="text-center text-muted py-5">Запустите основной анализ и затем оптимизацию.</div>
+                    </div>
+                </div>
+
             </div>
         </div>
     </div>
@@ -281,6 +325,7 @@
 <script>
     let currentData = null;
     let semanticData = null;
+    let optimizerData = null;
     let semanticTermSortBy = 'target_weight';
     let semanticTermSortDir = 'desc';
     let availableUserAgents = [];
@@ -486,11 +531,17 @@
                 competitor_titles: collectCompetitorTitles(),
                 semantic_threshold: Number(document.getElementById('semanticThreshold').value || 50),
                 semantic_compression: Number(document.getElementById('semanticCompression').value || 0.1),
-                semantic_query: document.getElementById('semanticQueryInput').value
+                semantic_query: document.getElementById('semanticQueryInput').value,
+                optimizer_base_url: document.getElementById('optimizerBaseUrl').value,
+                optimizer_model: document.getElementById('optimizerModel').value,
+                optimizer_iterations: Number(document.getElementById('optimizerIterations').value || 2),
+                optimizer_candidates: Number(document.getElementById('optimizerCandidates').value || 2),
+                optimizer_temperature: Number(document.getElementById('optimizerTemp').value || 0.25)
             },
             state: {
                 analysis_result: currentData,
-                semantic_result: semanticData
+                semantic_result: semanticData,
+                optimizer_result: optimizerData
             }
         };
 
@@ -529,6 +580,12 @@
         document.getElementById('semanticThreshold').value = 50;
         document.getElementById('semanticCompression').value = 0.1;
         document.getElementById('semanticQueryInput').value = '';
+        document.getElementById('optimizerApiKey').value = '';
+        document.getElementById('optimizerBaseUrl').value = 'https://api.deepseek.com/v1';
+        document.getElementById('optimizerModel').value = 'deepseek-chat';
+        document.getElementById('optimizerIterations').value = 2;
+        document.getElementById('optimizerCandidates').value = 2;
+        document.getElementById('optimizerTemp').value = 0.25;
 
         // Competitor text fields
         const competitorsList = document.getElementById('competitorsList');
@@ -541,6 +598,7 @@
         // Clear state
         currentData = null;
         semanticData = null;
+        optimizerData = null;
 
         // Reset result blocks
         document.getElementById('generalStats').innerHTML = '';
@@ -554,6 +612,7 @@
         document.getElementById('semanticDocSelect').innerHTML = '<option value="target">Мой текст</option>';
         document.getElementById('semanticResultsContainer').innerHTML = '<div class="text-center text-muted py-5">Нажмите "Запустить Semantic Core", чтобы построить граф и разметку.</div>';
         document.getElementById('summaryResultsContainer').innerHTML = '<div class="text-center text-muted py-5">Запустите анализ, чтобы увидеть итоговые рекомендации.</div>';
+        document.getElementById('optimizerResultsContainer').innerHTML = '<div class="text-center text-muted py-5">Запустите основной анализ и затем оптимизацию.</div>';
     }
 
     function applyProjectData(project) {
@@ -574,6 +633,11 @@
         document.getElementById('semanticThreshold').value = inp.semantic_threshold ?? 50;
         document.getElementById('semanticCompression').value = inp.semantic_compression ?? 0.1;
         document.getElementById('semanticQueryInput').value = inp.semantic_query || '';
+        document.getElementById('optimizerBaseUrl').value = inp.optimizer_base_url || 'https://api.deepseek.com/v1';
+        document.getElementById('optimizerModel').value = inp.optimizer_model || 'deepseek-chat';
+        document.getElementById('optimizerIterations').value = inp.optimizer_iterations ?? 2;
+        document.getElementById('optimizerCandidates').value = inp.optimizer_candidates ?? 2;
+        document.getElementById('optimizerTemp').value = inp.optimizer_temperature ?? 0.25;
 
         // Title character counter refresh
         const titleLen = (inp.target_title || '').length;
@@ -611,10 +675,12 @@
         // Restore cached analysis results if present
         currentData = project.state && project.state.analysis_result ? project.state.analysis_result : null;
         semanticData = project.state && project.state.semantic_result ? project.state.semantic_result : null;
+        optimizerData = project.state && project.state.optimizer_result ? project.state.optimizer_result : null;
 
         if (currentData) renderResults(currentData);
         if (semanticData) renderSemanticResults(semanticData);
         renderActionSummary(currentData, semanticData);
+        renderOptimizerResults(optimizerData);
     }
 
     document.getElementById('projectFileInput').addEventListener('change', function(e) {
@@ -675,6 +741,8 @@
             const data = await response.json();
             currentData = data;
             renderResults(data);
+            optimizerData = null;
+            renderOptimizerResults(null);
 
         } catch (error) {
             alert("Ошибка: " + error.message);
@@ -723,6 +791,118 @@
         }
     }
 
+    function renderOptimizerResults(data) {
+        const container = document.getElementById('optimizerResultsContainer');
+        if (!container) return;
+        if (!data) {
+            container.innerHTML = '<div class="text-center text-muted py-5">Запустите основной анализ и затем оптимизацию.</div>';
+            return;
+        }
+        if (!data.ok) {
+            container.innerHTML = `<div class="alert alert-danger">Ошибка оптимизации: ${data.error || 'unknown'}</div>`;
+            return;
+        }
+
+        const base = data.baseline_metrics || {};
+        const fin = data.final_metrics || {};
+        const rows = [
+            ['Composite score', base.score, fin.score],
+            ['BERT низких ключей', base.bert_low_count, fin.bert_low_count],
+            ['BM25 remove', base.bm25_remove_count, fin.bm25_remove_count],
+            ['N-gram signals', base.ngram_signal_count, fin.ngram_signal_count],
+            ['Title BERT', base.title_bert_score ?? '-', fin.title_bert_score ?? '-'],
+            ['Semantic gaps', base.semantic_gap_count, fin.semantic_gap_count],
+        ].map(r => `<tr><td>${r[0]}</td><td>${r[1]}</td><td>${r[2]}</td></tr>`).join('');
+
+        const iterRows = (data.iterations || []).map(it => {
+            const before = it.metrics_before ? it.metrics_before.score : '-';
+            const after = it.metrics_after ? it.metrics_after.score : '-';
+            return `<tr>
+                <td>${it.step}</td>
+                <td>${it.status}</td>
+                <td>${it.goal ? (it.goal.type + ': ' + (it.goal.label || '')) : '-'}</td>
+                <td>${before}</td>
+                <td>${after}</td>
+                <td>${it.delta_score ?? '-'}</td>
+            </tr>`;
+        }).join('');
+
+        container.innerHTML = `
+            <div class="stat-card">
+                <h6 class="card-title">Результат оптимизации</h6>
+                <div class="small mb-2">Применено правок: <strong>${data.applied_changes || 0}</strong></div>
+                <div class="table-responsive">
+                    <table class="table table-sm table-bordered mb-0">
+                        <thead class="table-light"><tr><th>Метрика</th><th>До</th><th>После</th></tr></thead>
+                        <tbody>${rows}</tbody>
+                    </table>
+                </div>
+            </div>
+            <div class="stat-card">
+                <h6 class="card-title">Лог итераций</h6>
+                <div class="table-responsive">
+                    <table class="table table-sm table-hover mb-0">
+                        <thead><tr><th>#</th><th>Статус</th><th>Цель</th><th>Score до</th><th>Score после</th><th>Δ</th></tr></thead>
+                        <tbody>${iterRows || '<tr><td colspan="6" class="text-muted text-center">Нет данных</td></tr>'}</tbody>
+                    </table>
+                </div>
+            </div>`;
+    }
+
+    function applyOptimizedText() {
+        if (!optimizerData || !optimizerData.ok || !optimizerData.optimized_text) {
+            alert('Нет результата оптимизации для применения.');
+            return;
+        }
+        document.getElementById('targetText').value = optimizerData.optimized_text;
+        alert('Оптимизированный текст подставлен в поле Target. Рекомендуется заново запустить анализ.');
+    }
+
+    async function runLlmOptimization() {
+        if (!currentData) {
+            alert('Сначала выполните основной анализ текста.');
+            return;
+        }
+
+        const apiKey = (document.getElementById('optimizerApiKey').value || '').trim();
+        if (!apiKey) {
+            alert('Введите API key для LLM.');
+            return;
+        }
+
+        const payload = {
+            target_text: document.getElementById('targetText').value || '',
+            competitors: collectCompetitorTexts(),
+            keywords: (document.getElementById('keywordsInput').value || '').split('\n').map(v => v.trim()).filter(Boolean),
+            language: document.getElementById('languageSelect').value || 'en',
+            target_title: document.getElementById('targetTitle').value || '',
+            competitor_titles: collectCompetitorTitles(),
+            api_key: apiKey,
+            api_base_url: (document.getElementById('optimizerBaseUrl').value || '').trim(),
+            model: (document.getElementById('optimizerModel').value || '').trim(),
+            max_iterations: Number(document.getElementById('optimizerIterations').value || 2),
+            candidates_per_iteration: Number(document.getElementById('optimizerCandidates').value || 2),
+            temperature: Number(document.getElementById('optimizerTemp').value || 0.25)
+        };
+
+        document.getElementById('loader').style.display = 'block';
+        try {
+            const response = await fetch('/api/v1/optimizer/run', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            if (!response.ok) throw new Error("Ошибка сервера: " + response.statusText);
+            optimizerData = await response.json();
+            renderOptimizerResults(optimizerData);
+        } catch (error) {
+            alert('Ошибка LLM оптимизации: ' + error.message);
+            console.error(error);
+        } finally {
+            document.getElementById('loader').style.display = 'none';
+        }
+    }
+
     async function runSemanticSearch() {
         const query = document.getElementById('semanticQueryInput').value;
         const lang = document.getElementById('languageSelect').value;