Added app folder and backend services

app/main.py

@@ -0,0 +1,33 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+# Router importu
+from app.routes import chat   # <--- chat.py dosyan buradan geliyor
+
+app = FastAPI(
+    title="AI Memory Graph",
+    version="0.1.0",
+    description="Triplet extraction, graph, query & QA"
+)
+
+# CORS (UI veya farklı origin’den çağrı için)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # ilk aşamada geniş bırak
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 🔗 Chat router'ını ekle
+app.include_router(chat.router, prefix="", tags=["memory-graph"])
+
+# ✅ Root path: GET + HEAD
+@app.api_route("/", methods=["GET", "HEAD"])
+def root():
+    return {"status": "ok", "service": "ai-memory-graph"}
+
+# Health endpoint (kontrol için)
+@app.get("/healthz")
+def healthz():
+    return {"status": "ok"}

app/routes/chat.py

@@ -0,0 +1,284 @@
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+from typing import List
+import os
+import json
+
+from app.services.nlp_triplet import extract_triplets_from_text
+from app.services.graph_builder import build_graph_from_triplets, export_graph_as_edges
+from app.services.memory_engine import (
+    group_by_author,
+    count_predicates,
+    most_common_subjects,
+    get_triplets_by_author,
+    get_triplets_by_subject,
+    get_triplets_by_predicate,
+    query_memory,
+)
+
+router = APIRouter()
+
+
+class Message(BaseModel):
+    sender: str
+    text: str
+    timestamp: str
+
+
+# ----------------------------------------------------------
+# Triplet Extraction
+# ----------------------------------------------------------
+@router.post("/extract")
+async def extract_triplets(messages: List[Message]):
+    all_triplets = []
+
+    for msg in messages:
+        extracted = extract_triplets_from_text(msg.text)
+        for triplet in extracted:
+            triplet["timestamp"] = msg.timestamp
+            triplet["author"] = msg.sender
+            all_triplets.append(triplet)
+
+    graph = build_graph_from_triplets(all_triplets)
+    edges = export_graph_as_edges(graph)
+
+    return {
+        "triplets": all_triplets,
+        "graph": edges
+    }
+
+
+# ----------------------------------------------------------
+# Triplet Statistics Summary
+# ----------------------------------------------------------
+@router.post("/memory-summary")
+async def memory_summary(messages: List[Message]):
+    all_triplets = []
+
+    for msg in messages:
+        extracted = extract_triplets_from_text(msg.text)
+        for triplet in extracted:
+            triplet["timestamp"] = msg.timestamp
+            triplet["author"] = msg.sender
+            all_triplets.append(triplet)
+
+    summary = {
+        "total_triplets": len(all_triplets),
+        "by_user": group_by_author(all_triplets),
+        "predicate_counts": count_predicates(all_triplets),
+        "common_subjects": most_common_subjects(all_triplets)
+    }
+
+    return summary
+
+
+# ----------------------------------------------------------
+# Triplet Query (Filtered)
+# ----------------------------------------------------------
+@router.post("/query")
+async def query_triplets(
+    messages: List[Message],
+    author: str = Query(None),
+    subject: str = Query(None),
+    predicate: str = Query(None)
+):
+    all_triplets = []
+
+    for msg in messages:
+        extracted = extract_triplets_from_text(msg.text)
+        for triplet in extracted:
+            triplet["timestamp"] = msg.timestamp
+            triplet["author"] = msg.sender
+            all_triplets.append(triplet)
+
+    filtered = all_triplets
+
+    if author:
+        filtered = get_triplets_by_author(filtered, author)
+    if subject:
+        filtered = get_triplets_by_subject(filtered, subject)
+    if predicate:
+        filtered = get_triplets_by_predicate(filtered, predicate)
+
+    return {
+        "total_triplets": len(filtered),
+        "results": filtered
+    }
+
+
+# ----------------------------------------------------------
+# Natural Language QA over Memory
+# ----------------------------------------------------------
+@router.get("/qa")
+async def qa_query(question: str = Query(..., description="Doğal dilde soru girin")):
+    filters = extract_query_from_question(question)
+    memory = load_memory()
+
+    print("🚀 SORU:", question)
+    print("🔍 FILTERS:", filters)
+
+    results = query_memory(
+        memory,
+        author=filters.get("author"),
+        predicate=filters.get("predicate"),
+        subject=filters.get("subject"),
+        object_=filters.get("object"),
+    )
+
+    print("📦 SONUÇ TRIPLETLER:", results)
+
+    answer = format_answer_smart(results, filters)
+
+    return {
+        "soru": question,
+        "filters": filters,
+        "cevap": answer,
+        "triplet_sayisi": len(results),
+        "tripletler": results
+    }
+
+
+
+@router.delete("/triplet/delete/{triplet_id}")
+async def delete_triplet(triplet_id: str):
+    memory = load_memory()
+    changed = False
+
+    for author, triplets in memory.items():
+        original_count = len(triplets)
+        memory[author] = [t for t in triplets if t.get("id") != triplet_id]
+        if len(memory[author]) < original_count:
+            changed = True
+
+    if changed:
+        _save_memory(memory)
+        return {"status": "deleted", "id": triplet_id}
+    else:
+        return {"status": "not found", "id": triplet_id}
+
+
+
+@router.put("/triplet/update/{triplet_id}")
+async def update_triplet(triplet_id: str, updated_fields: dict):
+    memory = load_memory()
+    updated = False
+
+    for author, triplets in memory.items():
+        for t in triplets:
+            if t.get("id") == triplet_id:
+                t.update(updated_fields)  # ✅ güncellenen alanları uygula
+                updated = True
+                break
+
+    if updated:
+        _save_memory(memory)
+        return {"status": "updated", "id": triplet_id, "new_data": updated_fields}
+    else:
+        return {"status": "not found", "id": triplet_id}
+
+
+
+
+# ----------------------------------------------------------
+# Helpers
+# ----------------------------------------------------------
+def extract_query_from_question(question: str) -> dict:
+    filters = {}
+    q = question.lower()
+
+    # --- AUTHOR eşleştirmeleri ---
+    if "ayşe" in q:
+        filters["author"] = "Ayşe"
+    if "erdem" in q:
+        filters["author"] = "Erdem"
+    if "ali" in q:
+        filters["author"] = "Ali"
+        
+    if "ne dedi" in q:
+        filters["return"] = "triplet"
+        return filters  # erken çık
+
+    # --- SUBJECT eşleştirmeleri ---
+    if "redis" in q:
+        filters["subject"] = "Redis"
+    if "react" in q:
+        filters["subject"] = "React"
+    if "fastapi" in q:
+        filters["subject"] = "FastAPI"
+    if "we" in q:
+        filters["subject"] = "we"
+    if "ben" in q or (" i " in q):  # boşluklarla eşleştir, yanlış anlamasın
+        filters["subject"] = "I"
+
+
+    # --- OBJECT eşleştirmeleri ---
+    if "mongodb" in q:
+        filters["object"] = "MongoDB"
+    if "ui" in q:
+        filters["object"] = "UI"
+    if "data" in q:
+        filters["object"] = "data"
+    if "joins" in q:
+        filters["object"] = "joins"
+    if "backend" in q:
+        filters["object"] = "backend"
+
+    # --- PREDICATE eşleştirmeleri ---
+    if "öner" in q or "tavsiye" in q:
+        filters["predicate"] = "suggest"
+    if "seviyor" in q or "sever" in q or "beğen" in q:
+        filters["predicate"] = "like"
+    if "destekliyor" in q or "destek" in q:
+        filters["predicate"] = "support"
+    if "düşünüyor" in q or "düşün" in q:
+        filters["predicate"] = "think"
+    if "önbellek" in q or "cache" in q:
+        filters["predicate"] = "cache"
+
+    # --- Geri dönüş tipi ---
+    if "ne dedi" in q or "kim ne dedi" in q:
+        filters["return"] = "triplet"
+    if "kim" in q:
+        filters["return"] = "subject"
+
+    return filters
+
+
+
+def format_answer_smart(triplets: list, filters: dict) -> str:
+    if not triplets:
+        return "Üzgünüm, bu soruya dair bir bilgi bulamadım."
+
+    return_type = filters.get("return")
+    messages = []
+
+    for triplet in triplets:
+        subj = triplet.get("subject")
+        pred = triplet.get("predicate")
+        obj = triplet.get("object")
+        author = triplet.get("author")
+
+        if return_type == "subject":
+            messages.append(f"{obj} ile ilgili eylemi gerçekleştiren kişi: {subj}")
+        elif return_type == "triplet":
+            messages.append(f"{author} dedi ki: \"{subj} {pred} {obj}\"")
+        else:
+            sentence = f"{author} dedi ki: \"{subj} {pred} {obj}\""
+            messages.append(sentence)
+
+    return "\n".join(messages)
+
+
+def load_memory():
+    base_dir = os.path.dirname(os.path.abspath(__file__))  # backend/app/routes/
+    full_path = os.path.abspath(os.path.join(base_dir, "..", "..", "memory_export.json"))
+    with open(full_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+    
+    
+def _save_memory(memory: dict):
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    full_path = os.path.abspath(os.path.join(base_dir, "..", "..", "memory_export.json"))
+    with open(full_path, "w", encoding="utf-8") as f:
+        json.dump(memory, f, indent=2, ensure_ascii=False)
+

app/services/graph_builder.py

@@ -0,0 +1,28 @@
+# backend/app/services/graph_builder.py
+
+import networkx as nx
+from typing import List, Dict
+
+def build_graph_from_triplets(triplets: List[Dict]) -> nx.DiGraph:
+    G = nx.DiGraph()
+
+    for triplet in triplets:
+        subject = triplet["subject"]
+        predicate = triplet["predicate"]
+        obj = triplet["object"]
+
+        G.add_node(subject)
+        G.add_node(obj)
+        G.add_edge(subject, obj, label=predicate)
+
+    return G
+
+def export_graph_as_edges(graph: nx.DiGraph) -> List[Dict]:
+    edges = []
+    for u, v, data in graph.edges(data=True):
+        edges.append({
+            "from": u,
+            "to": v,
+            "relation": data.get("label", "")
+        })
+    return edges

app/services/graph_visualizer.py

@@ -0,0 +1,20 @@
+# backend/app/services/graph_visualizer.py
+
+from pyvis.network import Network
+import networkx as nx
+
+def visualize_graph(graph: nx.DiGraph, output_path="graph.html"):
+    net = Network(height="600px", width="100%", directed=True)
+    net.barnes_hut()  # güzel bir düzenleme algoritması
+
+    for node in graph.nodes():
+        net.add_node(node, label=node)
+
+    for source, target, data in graph.edges(data=True):
+        label = data.get("label", "")
+        net.add_edge(source, target, label=label)
+
+    net.write_html(output_path)
+    ## import webbrowser
+    ## webbrowser.open(output_path)
+

app/services/memory_engine.py

@@ -0,0 +1,99 @@
+from typing import List, Dict
+from collections import defaultdict
+
+def group_by_author(triplets: List[Dict]) -> Dict[str, List[Dict]]:
+    memory = defaultdict(list)
+    for t in triplets:
+        memory[t["author"]].append(t)
+    return dict(memory)
+
+def count_predicates(triplets: List[Dict]) -> Dict[str, int]:
+    counts = defaultdict(int)
+    for t in triplets:
+        counts[t["predicate"]] += 1
+    return dict(counts)
+
+def most_common_subjects(triplets: List[Dict], top_n=3) -> List[str]:
+    counts = defaultdict(int)
+    for t in triplets:
+        counts[t["subject"]] += 1
+    sorted_subjects = sorted(counts.items(), key=lambda x: x[1], reverse=True)
+    return [s[0] for s in sorted_subjects[:top_n]]
+
+def get_triplets_by_author(triplets: List[Dict], author: str) -> List[Dict]:
+    return [t for t in triplets if t.get("author", "").lower() == author.lower()]
+
+def get_triplets_by_subject(triplets: List[Dict], subject: str) -> List[Dict]:
+    return [t for t in triplets if t.get("subject", "").lower() == subject.lower()]
+
+def get_triplets_by_predicate(triplets: List[Dict], predicate: str) -> List[Dict]:
+    return [t for t in triplets if t.get("predicate", "").lower() == predicate.lower()]
+
+import json
+
+import uuid
+import json
+from collections import defaultdict
+from typing import List, Dict
+
+def export_memory_to_json(triplets: List[Dict], output_path="backend/memory_export.json") -> None:
+    memory = defaultdict(list)
+
+    for t in triplets:
+        memory[t["author"]].append({
+            "id": str(uuid.uuid4()),  # ✅ benzersiz id
+            "subject": t["subject"],
+            "predicate": t["predicate"],
+            "object": t["object"],
+            "timestamp": t["timestamp"]
+        })
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(memory, f, indent=2, ensure_ascii=False)
+
+
+
+
+def query_memory(memory: dict, author=None, subject=None, predicate=None, object_=None):
+    results = []
+
+    for user, triplets in memory.items():
+        for triplet in triplets:
+            triplet_with_author = dict(triplet)  # orijinali değiştirmeyelim
+            triplet_with_author["author"] = user
+
+            if author and user != author:
+                continue
+            if subject and triplet.get("subject") != subject:
+                continue
+            if predicate and triplet.get("predicate") != predicate:
+                continue
+            if object_ and triplet.get("object") != object_:
+                continue
+
+            results.append(triplet_with_author)
+
+    return results
+
+
+# app/services/memory_engine.py
+
+
+
+import os
+
+def load_memory(path=None):
+    if path is None:
+        base_dir = os.path.dirname(os.path.abspath(__file__))
+        path = os.path.join(base_dir, "..", "..", "memory_export.json")
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def save_memory(memory: dict, path=None):
+    if path is None:
+        base_dir = os.path.dirname(os.path.abspath(__file__))
+        path = os.path.join(base_dir, "..", "..", "memory_export.json")
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(memory, f, indent=2, ensure_ascii=False)
+
+

app/services/nlp_triplet.py

@@ -0,0 +1,38 @@
+# backend/app/services/nlp_triplet.py
+
+import spacy
+from typing import List, Dict
+import os
+
+MODEL_NAME = os.getenv("SPACY_MODEL", "en_core_web_trf")
+try:
+    nlp = spacy.load(MODEL_NAME)
+except Exception:
+    # Transformer yoksa hafif modele düş
+    nlp = spacy.load("en_core_web_sm")
+
+def extract_triplets_from_text(text: str) -> List[Dict]:
+    doc = nlp(text)
+    triplets = []
+
+    for sent in doc.sents:
+        subject = ""
+        verb = ""
+        obj = ""
+
+        for token in sent:
+            if token.dep_ in ("nsubj", "nsubjpass"):
+                subject = token.text
+            if token.dep_ in ("dobj", "pobj", "attr"):
+                obj = token.text
+            if token.head.pos_ == "VERB":
+                verb = token.head.lemma_
+
+        if subject and verb and obj:
+            triplets.append({
+                "subject": subject,
+                "predicate": verb,
+                "object": obj
+            })
+
+    return triplets