RAG & AI ئالگورىزملىرى

# ── 1. ئىندېكسلاش (Indexing) ──────────────────────────
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter   import RecursiveCharacterTextSplitter
from langchain_openai           import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

# ھۆججەت يوللاش
loader = PyPDFLoader("uyghur_docs.pdf")
docs   = loader.load()

# بۆلۈش
splitter = RecursiveCharacterTextSplitter(
    chunk_size    = 512,
    chunk_overlap = 50,
    separators    = ["\n\n", "\n", ".", " "]
)
chunks = splitter.split_documents(docs)

# Vector DB غا ساقلاش
vectordb = Chroma.from_documents(
    documents  = chunks,
    embedding  = OpenAIEmbeddings(),
    persist_directory = "./chroma_db"
)

# ── 2. ئىزدەش + ھاسىللاش (RAG Chain) ────────────────
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA

llm       = ChatOpenAI(model="gpt-4o", temperature=0)
retriever = vectordb.as_retriever(search_kwargs={"k": 5})

rag_chain = RetrievalQA.from_chain_type(
    llm       = llm,
    retriever = retriever,
    return_source_documents = True
)

# سوئال سوراش
result = rag_chain.invoke({"query": "ئۇيغۇر تىلى قانداق تىل؟"})
print(result["result"])
print(result["source_documents"])

import numpy as np

def cosine_similarity(A, B):
    # ئەڭ كۆپ ئىشلىتىلىدۇ — يۆنىلىش ئوخشاشلىقى
    return np.dot(A, B) / (np.linalg.norm(A) * np.linalg.norm(B))

def euclidean_distance(A, B):
    # مەسىپە — تۆۋەن = ئوخشاش
    return np.sqrt(np.sum((A - B) ** 2))

def dot_product(A, B):
    # Normalized ۋېكتور ئۈچۈن تېز
    return np.dot(A, B)

# مىسال
king   = embed("king")    # → [0.82, 0.11, ...]
queen  = embed("queen")   # → [0.79, 0.14, ...]
banana = embed("banana")  # → [-0.3, 0.92, ...]

print(cosine_similarity(king, queen))   # → 0.94 (يېقىن)
print(cosine_similarity(king, banana))  # → 0.12 (يىراق)

# ── Pinecone (Production) ──────────────────────────────
import pinecone

pc = pinecone.Pinecone(api_key="...")
index = pc.Index("idirak-knowledge")

# ساقلاش
index.upsert(vectors=[
    {"id": "doc_1", "values": embedding, "metadata": {"text": "..."}},
])

# ئىزدەش
results = index.query(
    vector    = query_embedding,
    top_k     = 5,
    include_metadata = True
)

# ── FAISS (Local / Free) ───────────────────────────────
import faiss
import numpy as np

d     = 1536  # Embedding ئۆلچىمى
index = faiss.IndexFlatIP(d)  # Dot Product

# قوشۇش
vectors = np.array(embeddings, dtype='float32')
faiss.normalize_L2(vectors)
index.add(vectors)

# ئىزدەش
D, I = index.search(query_vec, 5)  # D=score, I=index

if "يېڭى بىلىم كېرەك (خەۋەر، شىركەت ھۆججىتى)":
    → RAG # مودېل بىلمەيدىغان بىلىمنى قوش

elif "ئۇسلۇپ ۋە تون ئۆزگەرتىش":
    → Fine-tuning # ئۆزگىچە ئاۋاز/ئۇسلۇپ

elif "ئالاھىدە ۋەزىپە (SQL، JSON، كود)":
    → Fine-tuning # ئانىق چىقىم فورماتى

elif "بىلىمنى داۋاملىق يېڭىلاش":
    → RAG # Fine-tuning قايتا-قايتا تەربىيىلەش كېرەك

elif "ئەڭ ياخشى نەتىجە كېرەك":
    → RAG + Fine-tuning # ئىككىسىنى بىرلەشتۈر

else:
    → RAG # سۈكۈتتىكى تاللاش

from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, TrainingArguments

# LoRA كونفىگۇراتسىيە
lora_config = LoraConfig(
    r              = 16,      # Rank — تۆۋەن = ئارزان، يۇقىرى = ئىقتىدارلىق
    lora_alpha     = 32,     # Scaling factor
    target_modules = ["q_proj", "v_proj"],  # قايسى قەۋەتلەر
    lora_dropout   = 0.05,
    bias           = "none",
    task_type      = "CAUSAL_LM"
)

# مودېل تەييارلاش
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-7B")
model = get_peft_model(model, lora_config)

# ئۆگىنىدىغان پارامېتر نىسبىتى
model.print_trainable_parameters()
# trainable: 0.64% (168M → 1M) — 99%+ يوللانمايدۇ!

Thought:  ئىشلەتكۈچى «idirak.com نىڭ ئالەكتىرون خەتى نېمە؟» دەپ سورىدى.
          ئىلكى ئىزدەشىم كېرەك.

Action:   web_search("idirak.com contact email")

Observation: نەتىجىدە info@idirak.com تېپىلدى.

Thought:  ئەمدى توغرا جاۋاپ بىرەلەيمەن.

Action:   finish("idirak.com نىڭ ئالاقە خەتى: info@idirak.com")

──────────────────────────────────────────────────────
# Python بىلەن ReAct مىسالى (LangChain)
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools  import DuckDuckGoSearchRun, PythonREPLTool

tools = [
    DuckDuckGoSearchRun(),  # تور ئىزدەش
    PythonREPLTool(),        # كود ئىجرا
]

agent    = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "ئاخىرقى iPhone باھاسى نەچچە؟"})

import anthropic

tools = [{
    "name": "get_weather",
    "description": "شەھەرنىڭ ھاۋارايى ئۇچۇرىنى ئالىش",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "شەھەر ئىسمى"}
        },
        "required": ["city"]
    }
}]

client   = anthropic.Anthropic()
response = client.messages.create(
    model    = "claude-sonnet-4-6",
    max_tokens = 1024,
    tools    = tools,
    messages = [{"role": "user", "content": "Oyama شەھىرىنىڭ ھاۋارايى?"}]
)

# Claude قورال چاقىرىش قارارى قىلىدۇ
if response.stop_reason == "tool_use":
    tool_call = response.content[0]
    # → {"name": "get_weather", "input": {"city": "Oyama"}}
    result = get_weather(tool_call.input["city"])
    # نەتىجىنى Claude غا قايتۇر

# (ئوبيېكت) → [مۇناسىۋەت] → (ئوبيېكت)

# مىسال: idirak.com ھەققىدە بىلىم گراپى
triples = [
    ("Idirak",      "قۇردى",        "idirak.com"),
    ("Idirak",      "تۇرىدۇ",       "Oyama, Japan"),
    ("idirak.com", "ئاساسلانغان", "Next.js"),
    ("idirak.com", "ئىشلىتىدۇ",   "Claude API"),
    ("Next.js",    "تىلى",         "TypeScript"),
    ("Claude API", "قۇرغۇچى",     "Anthropic"),
]

# Neo4j بىلەن ساقلاش
from neo4j import GraphDatabase

driver = GraphDatabase.driver("bolt://localhost", auth=("neo4j", "pass"))

with driver.session() as session:
    session.run("""
        MERGE (w:Person {name: 'Idirak'})
        MERGE (i:Website {name: 'idirak.com'})
        MERGE (w)-[:قۇردى]->(i)
    """)

# Cypher بىلەن سوئال سوراش
result = session.run("""
    MATCH (p:Person)-[r]->(x)
    WHERE p.name = 'Idirak'
    RETURN type(r) as relation, x.name as target
""")

SYSTEM_PROMPT = """
سەن idirak.com نىڭ AI ياردەمچىسىسەن.

## ھويىتىڭ
- ئىسمىڭ: Idirak AI
- تىلىڭ: ئۇيغۇرچە (ئىشلەتكۈچى ئۇيغۇرچە يازسا ئۇيغۇرچە جاۋاپ)
- ئۇسلۇبىڭ: كاسىپانە ۋە دوستانە

## قائىدىلەرڭ
1. پەقەت بىرىلگەن مەزمۇنغا ئاساسلانغان جاۋاپ بەر
2. بىلمىسەڭ ئاچىقچىلىق بىلەن «بىلمەيمەن» دە
3. جاۋابىڭنى ھەمىشە JSON شەكلىدە قايتۇر
4. ئىشەنچ دەرىجىسىنى كۆرسەت (0.0-1.0)

## چىقىم فورماتى
{
  "جاۋاپ": "...",
  "ئىشەنچ": 0.95,
  "مەنبە": ["doc_1", "doc_3"]
}
"""

# Chain-of-Thought مىسالى
CoT_PROMPT = """
تۆۋەندىكى مەسىلىنى ھەل قىل:

مەسىلە: {problem}

قەدەممۇ-قەدەم ئويلاپ جاۋاپ بەر:
1. مەسىلىنى چۈش: ...
2. مۇناسىۋەتلىك ئۇچۇر: ...
3. ھەل قىلىش يولى: ...
4. جاۋاپ: ...
"""

from pydantic import BaseModel
from openai   import OpenAI
from enum     import Enum

class Sentiment(Enum):
    POSITIVE = "مۇسبەت"
    NEGATIVE = "مەنپى"
    NEUTRAL  = "بىتەرەپ"

class SentimentResult(BaseModel):
    مۇناسىۋەت:    Sentiment
    ئىشەنچ:       float     # 0.0 - 1.0
    سەۋەب:        str
    ئاساسلىق_سۆز: list[str]

client   = OpenAI()
response = client.beta.chat.completions.parse(
    model           = "gpt-4o",
    messages        = [{"role": "user", "content": "بۇ مەزمۇننى تەھلىل قىل: ..."}],
    response_format = SentimentResult,
)
result = response.choices[0].message.parsed
# SentimentResult(مۇناسىۋەت=POSITIVE, ئىشەنچ=0.92, ...)

from ragas         import evaluate
from ragas.metrics import (
    faithfulness,       # جاۋاپ مەنبەگە ماسمۇ?
    answer_relevancy,   # جاۋاپ سوئالغا ماسمۇ?
    context_recall,     # مۇھىم ئۇچۇر تېپىلدىمۇ?
    context_precision,  # تېپىلغان مەزمۇن مۇناسىۋەتلىكمۇ?
)

dataset = {
    "question": ["RAG دېگەن نېمە؟"],
    "answer":   ["RAG ئىزدەش كۈچەيتىلگەن ھاسىللاش..."],
    "contexts": [["RAG (Retrieval-Augmented Generation)..."]],
    "ground_truth": ["RAG — LLM نى تاشقى مەنبەلەر بىلەن..."]
}

result = evaluate(
    dataset,
    metrics = [faithfulness, answer_relevancy,
               context_recall, context_precision]
)

# نەتىجە مىسالى:
# faithfulness:      0.92  ← يۇقىرى = ياخشى
# answer_relevancy:  0.88
# context_recall:    0.85
# context_precision: 0.91

from langchain.memory import (
    ConversationBufferMemory,     # قىسقا مۇددەتلىك
    ConversationSummaryMemory,     # خۇلاسىلىغان خاتىرە
    VectorStoreRetrieverMemory,   # ئۇزۇن مۇددەتلىك
)

# ── قىسقا مۇددەتلىك خاتىرە ──────────────────────────
short_memory = ConversationBufferMemory(
    max_token_limit = 2000,  # مەزمۇن دەرىچىسىنى چەكلە
    return_messages = True
)

# ── ئۇزۇن مۇددەتلىك خاتىرە (Vector DB) ─────────────
long_memory = VectorStoreRetrieverMemory(
    retriever = vectordb.as_retriever(search_kwargs={"k": 3}),
    memory_key = "long_term_history"
)

# ── ئىشلەتكۈچى ئۇچۇرى ساقلاش ──────────────────────
class UserMemory:
    def __init__(self, user_id):
        self.user_id  = user_id
        self.facts    = []

    def save_fact(self, fact):
        self.facts.append({
            "fact": fact,
            "user": self.user_id
        })
        vectordb.add_texts([fact])

    def recall(self, query):
        return vectordb.similarity_search(query, k=3)

# مىسال
mem = UserMemory("Idirak")
mem.save_fact("Idirak Next.js ۋە TypeScript ئىشلىتىدۇ")
mem.save_fact("Idirak Oyama, Japan دا تۇرىدۇ")

# كېيىنكى سۆھبەتتە
context = mem.recall("Idirak قانداق تېخنىكا ئىشلىتىدۇ?")
# → ["Next.js ۋە TypeScript ئىشلىتىدۇ"]