چشم انداز هوش مصنوعی به سرعت در حال تحول است و یکی از هیجان انگیز ترین روندها ، توانایی اجرای مدل های قدرتمند زبان بزرگ (LLMS) به طور مستقیم است روی دستگاه محلی شما

این تغییر از اعتماد به نفس روی API های مبتنی بر ابر از نظر حریم خصوصی ، مقرون به صرفه بودن و دسترسی آفلاین مزایای قابل توجهی را ارائه می دهند. توسعه دهندگان و علاقه مندان اکنون می توانند بدون ارسال داده های خارجی یا تحمل هزینه های API ، قابلیت های پیشرفته هوش مصنوعی را آزمایش و مستقر کنند.

این آموزش به عنوان یک دست کار عملی استon راهنمای استفاده از این قدرت محلی هوش مصنوعی. تمرکز دارد روی با استفاده از خانواده Qwen 3 از LLMS ، یک منبع برتر منبع باز از Alibaba ، همراه با Ollama ، ابزاری است که به طرز چشمگیری کار LLMS را به صورت محلی ساده می کند.

پیش نیازهای

قبل از غواصی در این آموزش ، باید درک بنیادی از برنامه نویسی پایتون داشته باشید و با استفاده از خط فرمان راحت باشید terminalبشر اطمینان حاصل کنید که Python 3 را نصب کرده اید روی سیستم شما

در حالی که تجربه قبلی با مدلهای AI یا زبان بزرگ (LLMS) مفید است ، ضروری نیست ، همانطور که من مفاهیم اصلی مانند بازیابی تولید شده (RAG) و عوامل AI را در طول راهنما معرفی و توضیح می دهم.

این آموزش به عنوان یک دست کار عملی استon راهنمای استفاده از این قدرت محلی هوش مصنوعی. تمرکز دارد روی با استفاده از خانواده Qwen 3 از LLMS ، یک منبع برتر منبع باز از Alibaba ، همراه با Ollama ، ابزاری است که به طرز چشمگیری کار LLMS را به صورت محلی ساده می کند.

فهرست مطالب

  1. Local قدرت AI با Qwen 3 و Ollama

    • اولاما: شما Local دروازه LLM

    • نقشه راه آموزش

  1. چگونه خود را تنظیم کنیم Local آزمایشگاه AI

    • اولاما را نصب کنید

    • مدل QWEN 3 خود را انتخاب کنید

    • Qwen 3 را با اولما بکشید و اجرا کنید

    • محیط پایتون خود را تنظیم کنید

  2. روش ساخت Local سیستم RAG با QWEN 3

    • مرحله 1: داده های خود را آماده کنید

    • مرحله 2: اسناد را در پایتون بارگیری کنید

    • مرحله 3: اسناد تقسیم شده

    • مرحله 4: مدل تعبیه را انتخاب و پیکربندی کنید

    • مرحله 5: تنظیم کنید Local فروشگاه وکتور (Chromadb)

    • مرحله 6: اسناد فهرست (جاسازی و ذخیره)

    • مرحله 7: زنجیره پارچه را بسازید

    • مرحله 8: اسناد خود را پرس و جو کنید

  3. روش ایجاد Local عوامل AI با Qwen 3

    • مرحله 1: ابزارهای سفارشی را تعریف کنید

    • مرحله 2: عامل LLM را تنظیم کنید

    • مرحله 3: سریع عامل را ایجاد کنید

    • مرحله 4: عامل را بسازید

    • مرحله 5: مجری نماینده را ایجاد کنید

    • مرحله 6: عامل را اجرا کنید

  4. ملاحظات پیشرفته و عیب یابی

    • کنترل حالت تفکر Qwen 3 با Ollama

    • مدیریت طول زمینه (num_ctx)

    • محدودیت های سخت افزار و VRAM

  5. نتیجه گیری و مراحل بعدی

Local قدرت AI با Qwen 3 و Ollama

اجرای LLM ها به صورت محلی چندین نگرانی مهم مرتبط با خدمات هوش مصنوعی مبتنی بر ابر را برطرف می کند.

  • حریم خصوصی مهم است – داده های پردازش شده به صورت محلی هرگز دستگاه کاربر را ترک نمی کنند.

  • هزینه یکی دیگر از عوامل مهم دیگر است-استفاده از مدل ها و ابزارهای منبع باز مانند Ollama هزینه های اشتراک API و هزینه های پرداخت شده را از بین می برد و باعث می شود هوش مصنوعی پیشرفته در دسترس همه باشد.

  • Local اجرای عملکرد عملکرد آفلاین – برای برنامه هایی که اتصال اینترنت غیرقابل اعتماد یا نامطلوب است ، بسیار مهم است.

اولاما: شما Local دروازه LLM

اولاما به عنوان یک پل عمل می کند و قدرت مدل هایی مانند Qwen 3 را در دسترس می کند روی سخت افزار محلی این یک است command-line ابزاری که بارگیری ، راه اندازی و اجرای LLM های مختلف منبع باز را در MacOS ، Linux و Windows ساده می کند.

Ollama پیچیدگی های پیکربندی مدل و استفاده از GPU را کنترل می کند و یک رابط کاربری ساده برای توسعه دهندگان و کاربران فراهم می کند. همچنین یک نقطه پایانی API سازگار با OpenAI را در معرض دید قرار می دهد و امکان ادغام یکپارچه در چارچوب های محبوب مانند Langchain را فراهم می کند.

نقشه راه آموزش

این آموزش شما را از طریق process از:

  1. تنظیم یک محیط AI محلی: نصب اولاما و انتخاب/اجرای مدل های مناسب QWEN 3.

  2. ساختن یک سیستم پارچه ای محلی: ایجاد سیستمی که امکان چت با اسناد شخصی را با استفاده از Qwen 3 ، Ollama ، Langchain و Chromadb برای ذخیره بردار فراهم می کند.

  3. ایجاد یک عامل اصلی AI محلی: تهیه یک عامل ساده با استفاده از QWEN 3 که می تواند از ابزارهای تعریف شده سفارشی (توابع) استفاده کند.

چگونه خود را تنظیم کنیم Local آزمایشگاه AI

اولین قدم تهیه دستگاه محلی خود با ابزارها و مدل های لازم است.

اولاما را نصب کنید

Ollama ساده ترین مسیر برای اجرای LLM ها را به صورت محلی فراهم می کند.

  • لینوکس / مکوس: باز terminal و اسکریپت نصب رسمی را اجرا کنید:

      curl -fsSL https://ollama.com/install.sh | sh

  • WINDOWS: نصب را از وب سایت Ollama (https://ollama.com/download) بارگیری کنید و دستورالعمل های تنظیم را دنبال کنید.

پس از نصب ، آن را با باز کردن یک جدید تأیید کنید terminal پنجره و دویدن:

ollama --version

اولاما به طور معمول مدل های بارگیری شده را در ~/.ollama/models روی macOS و /usr/share/ollama/.ollama/models روی لینوکس/WSL.

مدل QWEN 3 خود را انتخاب کنید

انتخاب مدل QWEN 3 راست بسیار مهم است و بستگی دارد روی کار مورد نظر و سخت افزار موجود ، در درجه اول سیستم RAM و GPU VRAM. اجرای مدل های بزرگتر به منابع بیشتری نیاز دارد اما به طور کلی عملکرد و قابلیت استدلال بهتری را ارائه می دهد.

Qwen 3 دو معماری اصلی را از طریق Ollama ارائه می دهد:

  • مدل های متراکم: (مثل qwen3:0.6bبا qwen3:4bبا qwen3:8bبا qwen3:14bبا qwen3:32b) این مدل ها تمام پارامترهای خود را در هنگام استنتاج فعال می کنند. عملکرد آنها قابل پیش بینی است ، اما نیاز منابع به طور مستقیم با تعداد پارامتر مقیاس می شود.

  • مدل های مخلوط (MOE) مدل ها: (مثل qwen3:30b-a3b) این مدل ها حاوی بسیاری از زیر شبکه های “متخصص” هستند اما فقط بخش کوچکی را برای هر نشانه ورودی فعال می کنند. این به آنها اجازه می دهد تا در حالی که هزینه های استنتاج را به کوچکتر خود نزدیک تر می کنند ، به ویژگی عملکرد تعداد پارامتر کل بزرگ خود (به عنوان مثال ، 30 میلیارد) دست یابند فعال تعداد پارامتر (به عنوان مثال ، 3 میلیارد). آنها تعادل قانع کننده ای از توانایی و کارآیی ، به ویژه برای استدلال و کارهای کدگذاری را ارائه می دهند.

توصیه برای این آموزش: برای مثالهایی که در زیر آمده است ، qwen3:8b تعادل خوبی بین توانایی و الزامات منابع برای بسیاری از ماشین های مدرن ایجاد می کند. اگر منابع محدودتر باشند ، qwen3:4b یک جایگزین مناسب است. مدل MOE qwen3:30b-a3b عملکرد بسیار خوبی را ارائه می دهد ، به خصوص برای برنامه نویسی و استدلال ، و به طرز شگفت آور خوبی اجرا می شود روی سیستم هایی با 16 گیگابایت+ VRAM به دلیل فعال شدن پراکنده آن.

Qwen 3 را با اولما بکشید و اجرا کنید

پس از انتخاب یک مدل ، باید آن را از طریق Ollama بارگیری کنید (آن را بکشید).

مدل را بکشید: باز کردن terminal و اجرا کنید (جایگزین کنید qwen3:8b با برچسب مورد نظر):

ollama pull qwen3:8b

این دستور وزن و پیکربندی مدل را بارگیری می کند.

تعاملی را اجرا کنید (تست اختیاری): برای گپ زدن مستقیم با مدل از خط فرمان:

ollama run qwen3:8b

نوع را مستقیماً وارد کنید terminalبشر استفاده کردن /bye برای خروج از جلسه سایر دستورات مفید در جلسه تعاملی شامل می شوند /? برای کمک و /set parameter <name> <value> (به عنوان مثال ، /set parameter num_ctx 8192) برای تغییر موقت پارامترهای مدل برای جلسه فعلی. استفاده کردن ollama list در خارج از جلسه برای دیدن مدل های بارگیری شده.

به عنوان سرور اجرا کنید: برای ادغام با اسکریپت های پایتون (با استفاده از Langchain) ، اولاما باید به عنوان یک سرور پس زمینه اجرا شود process، در معرض API. باز جدا کردن terminal پنجره و اجرا:

ollama serve

این را حفظ کنید terminal پنجره هنگام اجرای اسکریپت های پایتون باز است. این دستور سرور را شروع می کند ، به طور معمول گوش می دهد روی http://localhost:11434، ارائه یک نقطه پایانی API سازگار با OpenAI.

محیط پایتون خود را تنظیم کنید

یک محیط اختصاصی پایتون برای مدیریت وابستگی ها توصیه می شود.

ایجاد یک محیط مجازی:

python -m venv venv

محیط را فعال کنید:

  • MACOS/LINUX: source venv/bin/activate

  • WINDOWS: venv\Scripts\activate

کتابخانه های لازم را نصب کنید:

pip install langchain langchain-community langchain-core langchain-ollama chromadb sentence-transformers pypdf python-dotenv unstructured[pdf] tiktoken

  • langchainبا langchain-communityبا langchain-core: چارچوب اصلی Langchain برای ساخت برنامه های LLM.

  • langchain-ollama: ادغام خاص برای استفاده از مدل های Ollama با Langchain.

  • chromadb: پایگاه داده بردار محلی برای ذخیره تعبیه های سند.

  • sentence-transformers: مورد استفاده برای یک روش تعبیه محلی جایگزین (بعداً توضیح داده شد).

  • pypdf: کتابخانه برای بارگیری اسناد PDF.

  • python-dotenv: برای مدیریت متغیرهای محیط (عملکرد اختیاری اما خوب).

  • unstructured[pdf]: یک لودر اسناد جایگزین و قدرتمند ، به ویژه برای PDF های پیچیده.

  • tiktoken: توسط Langchain برای شمارش توکن استفاده می شود.

مجموعه محلی شامل هماهنگی چندین مؤلفه مستقل است: خود اولاما ، وزن مدل خاص Qwen 3 ، محیط پایتون و کتابخانه های مختلف مانند Langchain و Chromadb. تضمین سازگاری بین این قطعات و پیکربندی صحیح پارامترها (مانند اندازه پنجره متن اولما یا انتخاب یک مدل مناسب برای VRAM موجود) برای یک تجربه صاف مهم است.

در حالی که این مدولار انعطاف پذیری را ارائه می دهد – اجازه می دهد تا مؤلفه هایی مانند LLM یا فروشگاه وکتور مبادله شوند – این همچنین به این معنی است که تنظیم اولیه نیاز به توجه دقیق به جزئیات دارد. این آموزش با هدف ارائه مراحل واضح و پیش فرض های معقول برای به حداقل رساندن نقاط اصطکاک بالقوه انجام شده است.

پیشنهاد می‌کنیم بخوانید:  اگر __name__ == "__main__": در پایتون انجام دهید، چه می‌شود؟

روش ساخت Local سیستم RAG با QWEN 3

نسل بازیابی (RAG) یک تکنیک قدرتمند است که LLMS را با ارائه دانش خارجی به آنها تقویت می کند.

به جای تکیه فقط روی داده های آموزشی آن ، LLM می تواند اطلاعات مربوطه را از یک مجموعه سند مشخص (مانند PDF های محلی) بازیابی کند و از آن اطلاعات برای پاسخ به سؤالات استفاده می کند. این به طور قابل توجهی “توهم” (اطلاعات نادرست یا ساختگی) را کاهش می دهد و به LLM اجازه می دهد تا بدون نیاز به آموزش ، به سؤالات مربوط به داده های خاص و خصوصی پاسخ دهد.

پارچه اصلی process شامل:

  1. بارگیری و تقسیم اسناد به تکه های قابل کنترل.

  2. تبدیل این تکه ها به بازنمایی های عددی (تعبیه) با استفاده از یک مدل تعبیه شده.

  3. ذخیره این تعبیه ها در یک بانک اطلاعاتی بردار برای جستجوی کارآمد.

  4. هنگامی که یک پرس و جو وارد می شود ، پرس و جو را تعبیه کرده و در پایگاه داده بردار برای مشابه ترین تکه های سند جستجو می کنید.

  5. ارائه این بخش های مربوطه (زمینه) به همراه پرس و جو اصلی به LLM برای ایجاد یک پاسخ آگاهانه.

بیایید این کار را به صورت محلی با استفاده از Qwen 3 ، Ollama ، Langchain و Chromadb بسازیم.

مرحله 1: داده های خود را آماده کنید

دایرکتوری به نام ایجاد کنید data در پوشه پروژه سند PDF را که قصد دارید در این دایرکتوری پرس و جو کنید قرار دهید. برای این آموزش ، با استفاده از یک PDF تک ، در درجه اول مبتنی بر متن (مانند مقاله تحقیق یا گزارش) برای سادگی.

mkdir data
# Copy your PDF file into the 'data' directory
# e.g., cp ~/Downloads/some_paper.pdf./data/mydocument.pdf

اگر PDF را به راحتی در دسترس ندارید که می خواهید از آن استفاده کنید ، می توانید یک نمونه PDF (مقاله Llama 2) را برای این آموزش با استفاده از دستور زیر در خود بارگیری کنید terminal:


wget --user-agent "Mozilla" "https://arxiv.org/pdf/2307.09288.pdf" -O "data/llama2.pdf"

این دستور ایجاد می کند data دایرکتوری و بارگیری PDF ، ذخیره آن به عنوان llama2.pdf در داخل data دایرکتوری اگر ترجیح می دهید از سند خود استفاده کنید ، فایل PDF خود را در آن قرار دهید data دایرکتوری و نام پرونده را در کد بعدی پایتون به روز کنید.

مرحله 2: اسناد را در پایتون بارگیری کنید

برای خواندن محتوای PDF از لودرهای اسناد Langchain استفاده کنید. PyPDFLoader برای PDF های ساده ساده است. UnstructuredPDFLoader (نیاز دارد unstructured[pdf]) می تواند طرح های پیچیده تری را تحمل کند اما وابستگی بیشتری دارد.

# rag_local.py
import os
from dotenv import load_dotenv
from langchain_community.document_loaders import PyPDFLoader # Or UnstructuredPDFLoader

load_dotenv() # Optional: Loads environment variables from.env file

DATA_PATH = "data/"
PDF_FILENAME = "mydocument.pdf" # Replace with your PDF filename

def load_documents():
    """Loads documents from the specified data path."""
    pdf_path = os.path.join(DATA_PATH, PDF_FILENAME)
    loader = PyPDFLoader(pdf_path)
    # loader = UnstructuredPDFLoader(pdf_path) # Alternative
    documents = loader.load()
    print(f"Loaded {len(documents)} page(s) from {pdf_path}")
    return documents

# documents = load_documents() # Call this later

مرحله 3: اسناد تقسیم شده

اسناد بزرگ باید به تکه های کوچکتر مناسب برای تعبیه و بازیابی تقسیم شوند. در RecursiveCharacterTextSplitter تلاش برای تقسیم متن به صورت معنایی (در بندهای ، جملات و غیره روی) قبل از توسل به تقسیمات اندازه ثابت. chunk_size حداکثر اندازه هر تکه (در کاراکترها) را تعیین می کند ، و chunk_overlap مشخص می کند که چه تعداد شخصیت ها برای حفظ زمینه باید بین تکه های متوالی همپوشانی داشته باشند.

# rag_local.py (continued)
from langchain_text_splitters import RecursiveCharacterTextSplitter

def split_documents(documents):
    """Splits documents into smaller chunks."""
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len,
        is_separator_regex=False,
    )
    all_splits = text_splitter.split_documents(documents)
    print(f"Split into {len(all_splits)} chunks")
    return all_splits

# loaded_docs = load_documents()
# chunks = split_documents(loaded_docs) # Call this later

مرحله 4: مدل تعبیه را انتخاب و پیکربندی کنید

تعبیه ها متن را به بردارها تبدیل می کنند (لیست اعداد) به گونه ای که تکه های متنی از نظر معنایی دارای بردارهایی هستند که در فضای چند بعدی به هم نزدیک هستند.

این رویکرد از اولاما برای ارائه یک مدل تعبیه شده اختصاصی استفاده می کند. متن نامگذاری شده یک مدل منبع باز قادر است از طریق Ollama موجود است.

ابتدا اطمینان حاصل کنید که مدل تعبیه شده کشیده شده است:

ollama pull nomic-embed-text

سپس ، استفاده کنید OllamaEmbeddings در پایتون:

# rag_local.py (continued)
from langchain_ollama import OllamaEmbeddings

def get_embedding_function(model_name="nomic-embed-text"):
    """Initializes the Ollama embedding function."""
    # Ensure Ollama server is running (ollama serve)
    embeddings = OllamaEmbeddings(model=model_name)
    print(f"Initialized Ollama embeddings with model: {model_name}")
    return embeddings

# embedding_function = get_embedding_function() # Call this later

گزینه B (جایگزین): ترانسفورماتور جمله

این از کتابخانه جمله-ترانسفورماتور مستقیماً در اسکریپت پایتون استفاده می کند. نیاز به نصب کتابخانه دارد (pip انتقال دهنده های جمله را نصب کنید) اما به اولاما جداگانه احتیاج ندارد process برای تعبیه مدل هایی مانند All-Minilm-L6-V2 سریع و سبک هستند ، در حالی که All-MPNet-Base-V2 کیفیت بالاتری را ارائه می دهد.

# Alternative embedding function using Sentence Transformers
from langchain_community.embeddings import HuggingFaceEmbeddings

def get_embedding_function_hf(model_name="all-MiniLM-L6-v2"):
     """Initializes HuggingFace embeddings (runs locally)."""
     embeddings = HuggingFaceEmbeddings(model_name=model_name)
     print(f"Initialized HuggingFace embeddings with model: {model_name}")
     return embeddings

embedding_function = get_embedding_function_hf() # Use this if choosing Option B

برای این آموزش ، ما از گزینه A استفاده خواهیم کرد (Ollama تعبیه شده با nomic-embed-text) برای سازگاری با ابزار.

مرحله 5: تنظیم کنید Local فروشگاه وکتور (Chromadb)

Chromadb روشی کارآمد برای ذخیره و جستجوی تعبیه های وکتور محلی فراهم می کند. استفاده از یک مشتری مداوم تضمین می کند که داده های فهرست بندی شده در دیسک ذخیره می شوند و می توانند بدون پردازش مجدد اسناد هر بار بارگیری مجدد شوند.

# rag_local.py (continued)
from langchain_community.vectorstores import Chroma

CHROMA_PATH = "chroma_db" # Directory to store ChromaDB data

def get_vector_store(embedding_function, persist_directory=CHROMA_PATH):
    """Initializes or loads the Chroma vector store."""
    vectorstore = Chroma(
        persist_directory=persist_directory,
        embedding_function=embedding_function
    )
    print(f"Vector store initialized/loaded from: {persist_directory}")
    return vectorstore

embedding_function = get_embedding_function()
vector_store = get_vector_store(embedding_function) # Call this later

مرحله 6: اسناد فهرست (جاسازی و ذخیره)

این مرحله نمایه سازی اصلی است که تکه های اسناد به تعبیه ها تبدیل می شوند و در Chromadb ذخیره می شوند. در Chroma.from_documents عملکرد برای ایجاد و نمایه سازی اولیه مناسب است. اگر پایگاه داده از قبل وجود داشته باشد ، افزودنی های بعدی می توانند از آن استفاده کنند vectorstore.add_documentsبشر

# rag_local.py (continued)

def index_documents(chunks, embedding_function, persist_directory=CHROMA_PATH):
    """Indexes document chunks into the Chroma vector store."""
    print(f"Indexing {len(chunks)} chunks...")
    # Use from_documents for initial creation.
    # This will overwrite existing data if the directory exists but isn't a valid Chroma DB.
    # For incremental updates, initialize Chroma first and use vectorstore.add_documents().
    vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embedding_function,
        persist_directory=persist_directory
    )
    vectorstore.persist() # Ensure data is saved
    print(f"Indexing complete. Data saved to: {persist_directory}")
    return vectorstore

#... (previous function calls)
vector_store = index_documents(chunks, embedding_function) # Call this for initial indexing

برای بارگیری یک پایگاه داده مداوم موجود بعداً:

embedding_function = get_embedding_function()
vector_store = Chroma(persist_directory=CHROMA_PATH, embedding_function=embedding_function)

مرحله 7: زنجیره پارچه را بسازید

اکنون ، مؤلفه ها را در یک زنجیره زبان بیان Langchain (LCEL) جمع کنید. این شامل اولیه سازی QWEN 3 LLM از طریق OLLAMA ، ایجاد یک بازپرداخت از فروشگاه وکتور ، تعریف یک فوری مناسب و زنجیر کردن آنها در کنار هم است.

یک پارامتر بحرانی هنگام اولیه سازی ChatOllama برای راگ است num_ctxبشر این اندازه پنجره زمینه (در نشانه ها) را تعریف می کند که LLM می تواند از آن استفاده کند. پیش فرض اولاما (اغلب توکن های 2048 یا 4096) ممکن است خیلی کوچک باشد تا هم در زمینه سند بازیابی شده و هم پرس و جو/سریع کاربر را در خود جای دهد.

مدل های Qwen 3 (8b و بزرگتر) از پنجره های متن بسیار بزرگتر (به عنوان مثال ، نشانه های 128K) پشتیبانی می کنند ، اما محدودیت های عملی بستگی دارد روی RAM/VRAM موجود شما. تنظیم num_ctx به مقداری مانند 8192 یا بالاتر اغلب برای پارچه مؤثر ضروری است.

# rag_local.py (continued)
from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

def create_rag_chain(vector_store, llm_model_name="qwen3:8b", context_window=8192):
    """Creates the RAG chain."""
    # Initialize the LLM
    llm = ChatOllama(
        model=llm_model_name,
        temperature=0, # Lower temperature for more factual RAG answers
        num_ctx=context_window # IMPORTANT: Set context window size
    )
    print(f"Initialized ChatOllama with model: {llm_model_name}, context window: {context_window}")

    # Create the retriever
    retriever = vector_store.as_retriever(
        search_type="similarity", # Or "mmr"
        search_kwargs={'k': 3} # Retrieve top 3 relevant chunks
    )
    print("Retriever initialized.")

    # Define the prompt template
    template = """Answer the question based ONLY روی the following context:
{context}

Question: {question}
"""
    prompt = ChatPromptTemplate.from_template(template)
    print("Prompt template created.")

    # Define the RAG chain using LCEL
    rag_chain = (
        {"context": retriever, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
    )
    print("RAG chain created.")
    return rag_chain

#... (previous function calls)
vector_store = get_vector_store(embedding_function) # Assuming DB is already indexed
rag_chain = create_rag_chain(vector_store) # Call this later

اثربخشی سیستم RAG لولا روی پیکربندی مناسب هر مؤلفه. در chunk_size وت chunk_overlap در تقسیم کننده آنچه را که retriever پیدا می کند تأثیر می گذارد. انتخاب شما از embedding_function باید بین نمایه سازی و پرس و جو سازگار باشد. در num_ctx پارامتر برای ChatOllama LLM باید به اندازه کافی بزرگ باشد تا زمینه بازیابی شده و خود را سریع نگه دارد. یک الگوی سریع طراحی شده نیز می تواند LLM را گمراه کند. اطمینان حاصل کنید که این عناصر را برای عملکرد بهینه با دقت تنظیم کرده اید.

مرحله 8: اسناد خود را پرس و جو کنید

سرانجام ، با یک سؤال مربوط به محتوای PDF فهرست بندی شده ، زنجیره ای از Rag را فراخوانی کنید.

# rag_local.py (continued)

def query_rag(chain, question):
    """Queries the RAG chain and prints the response."""
    print("\nQuerying RAG chain...")
    print(f"Question: {question}")
    response = chain.invoke(question)
    print("\nResponse:")
    print(response)

# --- Main Execution ---
if __name__ == "__main__":
    # 1. Load Documents
    docs = load_documents()

    # 2. Split Documents
    chunks = split_documents(docs)

    # 3. Get Embedding Function
    embedding_function = get_embedding_function() # Using Ollama nomic-embed-text

    # 4. Index Documents (Only needs to be done once per document set)
    # Check if DB exists, if not, index. For simplicity, we might re-index here.
    # A more robust approach would check if indexing is needed.
    print("Attempting to index documents...")
    vector_store = index_documents(chunks, embedding_function)
    # To load existing DB instead:
    # vector_store = get_vector_store(embedding_function)

    # 5. Create RAG Chain
    rag_chain = create_rag_chain(vector_store, llm_model_name="qwen3:8b") # Use the chosen Qwen 3 model

    # 6. Query
    query_question = "What is the main topic of the document?" # Replace with a specific question
    query_rag(rag_chain, query_question)

    query_question_2 = "Summarize the introduction section." # Another example
    query_rag(rag_chain, query_question_2)

اسکریپت کامل را اجرا کنید (python rag_local.py). اطمینان حاصل کنید که ollama serve فرمان در دیگری اجرا می شود terminalبشر اسکریپت PDF را بارگیری می کند ، آن را تقسیم می کند ، تکه ها را با استفاده از آن جاسازی می کند nomic-embed-text از طریق Ollama ، آنها را در Chromadb ذخیره کنید ، با استفاده از زنجیره پارچه ای بسازید qwen3:8b از طریق اولاما ، و سرانجام نمایش داده ها را اجرا کنید. این print پاسخ های LLM مبتنی بر روی محتوای سند

روش ایجاد Local عوامل AI با Qwen 3

فراتر از پاسخ دادن به سوالات مبتنی بر روی متن ارائه شده ، LLMS می تواند به عنوان موتور استدلال برای عوامل هوش مصنوعی عمل کند. نمایندگان می توانند توالی اقدامات را برنامه ریزی کنند ، با ابزارهای خارجی (مانند توابع یا API) تعامل داشته باشند و در جهت دستیابی به اهداف پیچیده تری که توسط کاربر تعیین شده است ، تلاش کنند.

پیشنهاد می‌کنیم بخوانید:  روش مدیریت خطاهای کلیدی در پایتون – با مثال کد

مدل های QWEN 3 به طور خاص با قابلیت تماس با ابزار قوی و عامل طراحی شده اند. در حالی که Alibaba چارچوب Qwen-Agent را فراهم می کند ، این آموزش با استفاده از Langchain برای قوام ادامه خواهد یافت و به دلیل ادغام آن با Ollama برای کارهای عامل به راحتی در مواد ارائه شده مستند شده است.

ما یک عامل ساده ایجاد خواهیم کرد که می تواند از یک عملکرد Python سفارشی به عنوان ابزاری استفاده کند.

مرحله 1: ابزارهای سفارشی را تعریف کنید

ابزارها توابع استاندارد پایتون هستند که عامل می تواند برای اجرای آن انتخاب کند. Docstring عملکرد بسیار مهم است ، زیرا LLM از آن استفاده می کند تا بفهمد ابزار چه کاری انجام می دهد و چه استدلالی را می طلبد. لانگچین @tool دکوراتور توابع بسته بندی را برای استفاده از عامل ساده می کند.

# agent_local.py
import os
from dotenv import load_dotenv
from langchain.agents import tool
import datetime

load_dotenv() # Optional

@tool
def get_current_datetime(format: str = "%Y-%m-%d %H:%M:%S") -> str:
    """
    Returns the current date and time, formatted according to the provided Python strftime format string.
    Use this tool whenever the user asks for the current date, time, or both.
    Example format strings: '%Y-%m-%d' for date, '%H:%M:%S' for time.
    If no format is specified, defaults to '%Y-%m-%d %H:%M:%S'.
    """
    try:
        return datetime.datetime.now().strftime(format)
    except Exception as e:
        return f"Error formatting date/time: {e}"

# List of tools the agent can use
tools = [get_current_datetime]
print("Custom tool defined.")

مرحله 2: عامل LLM را تنظیم کنید

فوری ChatOllama دوباره مدل ، با استفاده از یک نوع QWEN 3 مناسب برای تماس با ابزار. در qwen3:8b مدل باید قادر به رسیدگی به موارد ساده استفاده از ابزار باشد.

توجه به این نکته حائز اهمیت است که قابلیت اطمینان از ابزار با مدل های محلی که از طریق اولاما ارائه می شود ، گاهی اوقات می تواند کمتر از API های تجاری بزرگ مانند GPT-4 یا Claude باشد. LLM ممکن است در هنگام نیاز به ابزاری ، آرگومان های توهم یا تفسیر نادرست از خروجی ابزار ، نتواند تشخیص دهد. شروع با ارسال های شفاف و ابزارهای ساده توصیه می شود.

# agent_local.py (continued)
from langchain_ollama import ChatOllama

def get_agent_llm(model_name="qwen3:8b", temperature=0):
    """Initializes the ChatOllama model for the agent."""
    # Ensure Ollama server is running (ollama serve)
    llm = ChatOllama(
        model=model_name,
        temperature=temperature # Lower temperature for more predictable tool use
        # Consider increasing num_ctx if expecting long conversations or complex reasoning
        # num_ctx=8192
    )
    print(f"Initialized ChatOllama agent LLM with model: {model_name}")
    return llm

# agent_llm = get_agent_llm() # Call this later

مرحله 3: سریع عامل را ایجاد کنید

نمایندگان به ساختارهای سریع خاصی نیاز دارند که استدلال و استفاده از ابزار آنها را راهنمایی می کنند. این سریع به طور معمول شامل متغیرها برای ورودی کاربر (input) ، تاریخ مکالمه (chat_history) ، و agent_scratchpadبشر Scratchpad جایی است که عامل “فکر” داخلی خود را ثبت می کند process، ابزارهایی که تصمیم می گیرد با آن تماس بگیرد ، و نتایج (مشاهدات) که از آن ابزارها باز می گردد. HUB Langchain Prompens از پیش ساخته شده مناسب برای عوامل تماس با ابزار را فراهم می کند.

# agent_local.py (continued)
from langchain import hub

def get_agent_prompt(prompt_hub_name="hwchase17/openai-tools-agent"):
    """Pulls the agent prompt template from LangChain Hub."""
    # This prompt is designed for OpenAI but often works well with other tool-calling models.
    # Alternatively, define a custom ChatPromptTemplate.
    prompt = hub.pull(prompt_hub_name)
    print(f"Pulled agent prompt from Hub: {prompt_hub_name}")
    # print("Prompt Structure:")
    # prompt.pretty_print() # Uncomment to see the prompt structure
    return prompt

# agent_prompt = get_agent_prompt() # Call this later

مرحله 4: عامل را بسازید

در create_tool_calling_agent تابع ترکیب LLM ، ابزارهای تعریف شده و اعلان را به یک واحد قابل اجرا که نمایانگر منطق اصلی عامل است ، ترکیب می کند.

# agent_local.py (continued)
from langchain.agents import create_tool_calling_agent

def build_agent(llm, tools, prompt):
    """Builds the tool-calling agent runnable."""
    agent = create_tool_calling_agent(llm, tools, prompt)
    print("Agent runnable created.")
    return agent

# agent_runnable = build_agent(agent_llm, tools, agent_prompt) # Call this later

مرحله 5: مجری نماینده را ایجاد کنید

در AgentExecutor مسئول اجرای حلقه عامل است. این عامل قابل اجرا است و ابزارها ، عامل را با ورودی فراخوانی می کند ، خروجی عامل را تجزیه می کند (که می تواند یک پاسخ نهایی یا درخواست تماس ابزار باشد) ، هرگونه تماس ابزار درخواست شده را اجرا می کند و نتایج را به عامل باز می گرداند تا یک پاسخ نهایی. تنظیم verbose=True در طول توسعه برای مشاهده جریان مرحله به مرحله عامل بسیار توصیه می شود.

# agent_local.py (continued)
from langchain.agents import AgentExecutor

def create_agent_executor(agent, tools):
    """Creates the agent executor."""
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True # Set to True to see agent thoughts and tool calls
    )
    print("Agent executor created.")
    return agent_executor

# agent_executor = create_agent_executor(agent_runnable, tools) # Call this later

مرحله 6: عامل را اجرا کنید

مجری عامل را با یک پرس و جو کاربر که باید استفاده از ابزار تعریف شده را تحریک کند ، فراخوانی کنید.

# agent_local.py (continued)

def run_agent(executor, user_input):
    """Runs the agent executor with the given input."""
    print("\nInvoking agent...")
    print(f"Input: {user_input}")
    response = executor.invoke({"input": user_input})
    print("\nAgent Response:")
    print(response['output'])

# --- Main Execution ---
if __name__ == "__main__":
    # 1. Define Tools (already done above)

    # 2. Get Agent LLM
    agent_llm = get_agent_llm(model_name="qwen3:8b") # Use the chosen Qwen 3 model

    # 3. Get Agent Prompt
    agent_prompt = get_agent_prompt()

    # 4. Build Agent Runnable
    agent_runnable = build_agent(agent_llm, tools, agent_prompt)

    # 5. Create Agent Executor
    agent_executor = create_agent_executor(agent_runnable, tools)

    # 6. Run Agent
    run_agent(agent_executor, "What is the current date?")
    run_agent(agent_executor, "What time is it right now? Use HH:MM format.")
    run_agent(agent_executor, "Tell me a joke.") # Should not use the tool

دویدن python agent_local.py (با ollama serve فعال) عامل را اجرا می کند. در verbose=True تنظیم print خروجی شبیه به چارچوب React (استدلال و بازیگری) ، نشان دادن “افکار” داخلی عامل روی چگونه می توان ادامه داد ، “عمل” تصمیم می گیرد (تصمیم بگیرد (یک ابزار خاص با استدلال) و “مشاهده” (نتیجه برگشتی توسط ابزار).

ایجاد عوامل قابل اعتماد با مدل های محلی چالش های منحصر به فردی را نشان می دهد. توانایی LLM در تفسیر صحیح سریع ، درک اینکه چه زمانی از ابزارها استفاده کنید ، ابزار مناسب را انتخاب کنید ، آرگومان های معتبر تولید کنید و process خروجی ابزار بسیار مهم است.

Local مدل ها ، به ویژه مدل های کوچکتر یا به شدت کم نظیر ، ممکن است در مقایسه با همتایان بزرگتر و مبتنی بر ابر با این مراحل استدلال مبارزه کنند. اگر qwen3:8b مدل برای کارهای پیچیده تر عامل غیر قابل اعتماد است ، تلاش را در نظر بگیرید qwen3:14b یا کارآمد qwen3:30b-a3b اگر سخت افزار اجازه می دهد.

برای گردش کار بسیار پیچیده یا دولتی ، کاوش در چارچوب هایی مانند Langgraph ، که کنترل بیشتری بر جریان اجرای عامل ارائه می دهد ، ممکن است مفید باشد.

ملاحظات پیشرفته و عیب یابی

اجرای LLMS به صورت محلی انعطاف پذیری بسیار خوبی را ارائه می دهد ، اما همچنین جنبه های پیکربندی خاص و مسائل بالقوه را معرفی می کند.

کنترل حالت تفکر Qwen 3 با Ollama

استنباط ترکیبی منحصر به فرد Qwen 3 اجازه می دهد تا بین یک حالت “تفکر” عمیق برای استدلال پیچیده و یک حالت سریعتر “غیر فکر” برای گپ عمومی جابجا شود. در حالی که چارچوب هایی مانند بغل کردن ترانسفورماتورهای صورت یا VLLM ممکن است پارامترهای صریح ارائه دهند (enable_thinking) ، راه اصلی برای کنترل این کار هنگام استفاده از Ollama از طریق “سوئیچ های نرم” تعبیه شده در سریع است.

ضمیمه کردن /think تا پایان یک کاربر سریعاً استدلال گام به گام را تشویق می کند ، یا /no_think برای پاسخ سریعتر و مستقیم. شما می توانید این کار را از طریق Ollama CLI یا به طور بالقوه در اعلان های ارسال شده از طریق API/Langchain انجام دهید.

# Example using LangChain's ChatOllama
from langchain_ollama import ChatOllama

llm_think = ChatOllama(model="qwen3:8b")
llm_no_think = ChatOllama(model="qwen3:8b") # Could also set system prompt

# Invoke with prompt modification
response_think = llm_think.invoke("Solve the equation 2x + 5 = 15 /think")
print("Thinking Response:", response_think)

response_no_think = llm_no_think.invoke("What is the capital of France? /no_think")
print("Non-Thinking Response:", response_no_think)

# Alternatively, set via system message (might be less reliable turn-by-turn)
llm_system_no_think = ChatOllama(model="qwen3:8b", system="/no_think")
response_system = llm_system_no_think.invoke("What is 2+2?")
print("System No-Think Response:", response_system)

توجه داشته باشید که پایداری این برچسب ها در چندین چرخش در یک مکالمه ممکن است نیاز به مدیریت سریع دقیق داشته باشد.

مدیریت طول زمینه (num_ctx)

پنجره زمینه (num_ctx) تعیین می کند که چقدر اطلاعات (سریع ، تاریخ ، اسناد بازیابی شده) LLM می تواند یکباره را در نظر بگیرد. مدل های Qwen 3 (8b+) از طول زمینه های بومی بزرگ (به عنوان مثال ، توکن 128K) پشتیبانی می کنند ، اما اولاما اغلب به یک پنجره بسیار کوچکتر (مانند 2048 یا 4096) پیش فرض می شود. برای RAG یا مکالمه هایی که نیاز به حافظه نوبت های قبلی دارند ، این پیش فرض اغلب کافی نیست.

تنظیم کردن num_ctx هنگام شروع کار ChatOllama یا OllamaLLM در لانگچین:

# Example setting context window to 8192 tokens
llm = ChatOllama(model="qwen3:8b", num_ctx=8192)

توجه داشته باشید که بزرگتر num_ctx مقادیر به طور قابل توجهی مصرف RAM و VRAM را افزایش می دهد. اما تنظیم بیش از حد آن می تواند منجر به “فراموش کردن” مدل یا حتی ورود به حلقه های تکراری شود. مقداری را انتخاب کنید که نیازهای کار را با قابلیت های سخت افزاری متعادل کند.

محدودیت های سخت افزار و VRAM

اجرای LLMS به صورت محلی منابع پررنگ است.

  • VRAM: یک GPU اختصاصی (NVIDIA یا SILICON APPLE) با VRAM کافی برای عملکرد قابل قبول بسیار توصیه می شود. مقدار VRAM بزرگترین اندازه مدل را که می تواند به طور مؤثر اجرا کند ، دیکته می کند. برای تخمین به جدول در بخش 2 مراجعه کنید.

  • RAM: RAM سیستم نیز بسیار مهم است ، به خصوص اگر این مدل کاملاً در VRAM جای نگیرد. اولاما می تواند از RAM سیستم به عنوان یک بازپرداخت استفاده کند ، اما این به طور قابل توجهی کندتر است.

  • کمیت: اولاما به طور معمول مدلهای کمیت (به عنوان مثال ، 4 بیتی یا 5 بیتی) را ارائه می دهد ، که اندازه مدل و نیازهای VRAM را به طور قابل توجهی در مقایسه با مدلهای با دقت کامل کاهش می دهد ، اغلب با حداقل تخریب عملکرد برای بسیاری از کارها. برچسب ها مانند :4bبا :8b معمولاً حاکی از یک سطح کمیت پیش فرض است.

اگر عملکرد کند است یا خطاها به دلیل محدودیت منابع رخ می دهد ، در نظر بگیرید:

  • با استفاده از یک مدل کوچکتر QWEN 3 (مانند 4b به جای 8b).

  • اطمینان از اینکه اولاما به درستی در حال تشخیص و استفاده از GPU است (سیاهههای مربوط به Ollama یا ابزارهای نظارت بر سیستم را بررسی کنید).

  • بسته شدن سایر برنامه های فشرده منابع.

نتیجه گیری و مراحل بعدی

این آموزش برای راه اندازی محیط AI محلی خود با استفاده از خانواده قدرتمند و باز QWEN 3 LLM با ابزار کاربر پسند Ollama ، به شما یک پیاده روی عملی داد.

اگر این مراحل را دنبال کرده اید ، باید با موفقیت:

  1. Ollama را نصب کرده و مدل QWEN 3 را به صورت محلی بارگیری و اجرا کرد.

  2. خط لوله تولید بازیابی (RAG) با استفاده از Langchain و Chromadb را برای پرس و جو از اسناد محلی ساخته است.

  3. یک عامل اصلی هوش مصنوعی ایجاد کرده است که قادر به استدلال و استفاده از ابزارهای سفارشی پایتون است.

اجرای این سیستم ها به صورت محلی مزایای قابل توجهی را در حریم خصوصی ، هزینه و سفارشی سازی باز می کند و باعث می شود قابلیت های پیشرفته هوش مصنوعی از همیشه در دسترس باشد. ترکیبی از عملکرد Qwen 3 و مجوز آزاد با سهولت استفاده اولما ، یک بستر قدرتمند برای آزمایش و توسعه ایجاد می کند.

منابع رسمی:

  • Qwen 3: github ، Documentation

  • اولاما: وب سایت ، کتابخانه مدل ، github

  • Langchain: پیتون Documentation

  • Chromadb: Documentation

  • ترانسفورماتور جمله: Documentation

با استفاده از این ابزارهای قدرتمند ، رایگان و منبع باز ، می توانید همچنان به مرزهای آنچه ممکن است با استفاده مستقیم از AI در حال اجرا باشد ، ادامه دهید روی سخت افزار شخصی شما