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 ئىشلىتىدۇ"]