മുമ്പത്തെ ലേഖനത്തിൽ, Deep Agents CLI ഉപയോഗിച്ച് Skills ഉപയോഗിക്കുന്ന Deep Agent മോഡലിനെക്കുറിച്ച് നമ്മൾ ചർച്ച ചെയ്തു. ഇന്ന്, LangChain ഈ ഫീച്ചറിനെ പിന്തുണയ്ക്കുന്നതിനാൽ, ഡെവലപ്‌മെന്റ് പ്രക്രിയ കൂടുതൽ ലളിതമായിരിക്കുന്നു. ഈ ലേഖനത്തിൽ, ഒരു സ്മാർട്ട് SQL അസിസ്റ്റന്റ് നിർമ്മിക്കുന്നതിനായി ഈ ഫീച്ചറിലേക്ക് ആഴത്തിൽ ഇറങ്ങിച്ചെല്ലാം.

സങ്കീർണ്ണമായ AI ഏജന്റുകൾ നിർമ്മിക്കുമ്പോൾ, ഡെവലപ്പർമാർ പലപ്പോഴും ഒരു വിഷ dilemma-യിൽ അകപ്പെടുന്നു: എല്ലാ കോൺടെക്സ്റ്റുകളും (ഡാറ്റാബേസ് ടേബിൾ ഘടന, API ഡോക്യുമെന്റേഷൻ, ബിസിനസ്സ് നിയമങ്ങൾ) ഒരേസമയം സിസ്റ്റം പ്രോംപ്റ്റിലേക്ക് ചേർക്കുന്നത് Context Window നിറഞ്ഞ് മോഡലിന്റെ ശ്രദ്ധ വ്യതിചലിപ്പിക്കാൻ കാരണമാകുമോ? അതോ ഉയർന്ന ചിലവുള്ള ഫ്രീക്വൻ്റ് ഫൈൻ-ട്യൂണിംഗ് (Fine-tuning) തിരഞ്ഞെടുക്കണോ?

Skills മോഡൽ (Skills Pattern) ഒരു മികച്ച പരിഹാരം നൽകുന്നു. ആവശ്യമായ ഡാറ്റകൾ ഡൈനാമിക് ആയി ശേഖരിക്കുന്നതിലൂടെ, കോൺടെക്സ്റ്റ് കാര്യക്ഷമമായി ഉപയോഗിക്കാൻ ഇത് സഹായിക്കുന്നു. LangChain ഈ മോഡലിനെ പിന്തുണയ്ക്കുന്നതിലൂടെ, "ആവശ്യാനുസരണം പഠിക്കാൻ" കഴിവുള്ള ഒരു ഏജന്റിനെ നമുക്ക് എളുപ്പത്തിൽ നിർമ്മിക്കാൻ കഴിയും.

ഈ ലേഖനത്തിൽ, ഔദ്യോഗിക ഡോക്യുമെന്റേഷനായ Build a SQL assistant with on-demand skills-മായി ചേർന്ന്, "ആവശ്യാനുസരണം ഡാറ്റകൾ ശേഖരിക്കാൻ" കഴിയുന്ന ഒരു SQL അസിസ്റ്റന്റ് എങ്ങനെ നിർമ്മിക്കാമെന്ന് പഠിക്കാം.

1. പ്രധാന ആശയം: എందుకు Skills മോഡൽ തിരഞ്ഞെടുക്കണം?

പരമ്പരാഗത SQL ഏജന്റിന്റെ പരിമിതികൾ

പരമ്പരാഗത SQL ഏജന്റ് ആർക്കിടെക്ചറിൽ, നമ്മൾ സാധാരണയായി ഡാറ്റാബേസ് സ്കീമ (Database Schema) മുഴുവനായി സിസ്റ്റം പ്രോംപ്റ്റിൽ നൽകേണ്ടി വരും. ബിസിനസ്സ് വികസിക്കുന്നതിനനുസരിച്ച്, ടേബിളുകളുടെ എണ്ണം നൂറുകണക്കിന് ആകുമ്പോൾ, ഈ രീതിയിൽ ചില പ്രശ്നങ്ങളുണ്ടാകാം:

• Token-കളുടെ വലിയ ഉപഭോഗം: ഓരോ സംഭാഷണത്തിലും ധാരാളം ആവശ്യമില്ലാത്ത ടേബിൾ ഘടനകൾ കൊണ്ടുപോകുന്നത് റിസോഴ്സുകളുടെ പാഴാകലിന് കാരണമാകുന്നു.

• ഹാലുസിനേഷൻ സാധ്യത വർദ്ധിക്കുന്നു: ധാരാളം ആവശ്യമില്ലാത്ത വിവരങ്ങൾ മോഡലിന്റെ കൃത്യത കുറയ്ക്കുന്നു.

• പരിപാലിക്കാൻ ബുദ്ധിമുട്ട്: എല്ലാ ബിസിനസ്സ് ലൈനുകളുടെയും ഡാറ്റകൾ ഒരുമിച്ച് ചേർന്നിരിക്കുന്നതിനാൽ, സ്വതന്ത്രമായി മാറ്റങ്ങൾ വരുത്താൻ കഴിയില്ല.

Skills മോഡൽ: ക്രമേണയുള്ള വെളിപ്പെടുത്തലിനെ അടിസ്ഥാനമാക്കിയുള്ള പരിഹാരം

Skills മോഡൽ ക്രമേണയുള്ള വെളിപ്പെടുത്തൽ (Progressive Disclosure) എന്ന തത്വത്തെ അടിസ്ഥാനമാക്കി ഡാറ്റകൾ നേടുന്ന പ്രക്രിയയെ തരംതിരിക്കുന്നു:

• ഏജന്റിന്റെ പ്രാരംഭ അവസ്ഥ: ഏത് "നൈപുണ്യമാണ്" (Skills) ഉള്ളതെന്നും അതിന്റെ ലളിതമായ വിവരണം (Description) എന്താണെന്നും മാത്രം അറിയുക, ഭാരം കുറഞ്ഞതായിരിക്കുക.

• റൺടൈം ലോഡിംഗ്: ഒരു പ്രത്യേക പ്രശ്നം (ഉദാഹരണത്തിന്, "ഇൻവെൻ്ററി അന്വേഷിക്കുക") ഉണ്ടാകുമ്പോൾ, ഏജന്റ് ടൂളുകൾ ഉപയോഗിച്ച് (load_skill) ആ നൈപുണ്യത്തിൻ്റെ വിശദമായ ഡാറ്റകൾ (Schema + Prompt) ശേഖരിക്കുന്നു.

• ജോലി പൂർത്തിയാക്കുക: ശേഖരിച്ച കൃത്യമായ ഡാറ്റകളെ അടിസ്ഥാനമാക്കി, നിർദ്ദിഷ്ട ടാസ്‌ക്കുകൾ (SQL എഴുതുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുക) നടപ്പിലാക്കുക.

ഈ മോഡൽ പരിധിയില്ലാത്ത വിപുലീകരണത്തെയും (infinite expansion) ടീം വേർതിരിവിനെയും (team decoupling) പിന്തുണയ്ക്കുന്നു, കൂടാതെ ഏജന്റിനെ കൂടുതൽ സങ്കീർണ്ണമായ ബിസിനസ്സ് സാഹചര്യങ്ങളുമായി പൊരുത്തപ്പെടാൻ സഹായിക്കുന്നു.

2. സിസ്റ്റം ആർക്കിടെക്ചർ ഡിസൈൻ

ഈ പ്രോജക്റ്റ്, Skills മോഡലിന്റെ ഉപയോഗം കാണിക്കുന്നതിനായി രണ്ട് പ്രധാന Skills അടങ്ങിയ ഒരു SQL അസിസ്റ്റന്റിനെ നിർമ്മിക്കുന്നു:

• Sales Analytics (വിൽപ്പന സ്ഥിതിവിവരക്കണക്കുകൾ): sales_data എന്ന ടേബിളിന്റെ ഉത്തരവാദിത്തം, വരുമാനം, ഓർഡർ വിശകലനം ​​എന്നിവ കൈകാര്യം ചെയ്യുന്നു.

• Inventory Management (ഇൻവെൻ്ററി മാനേജ്മെൻ്റ്): inventory_items എന്ന ടേബിളിന്റെ ഉത്തരവാദിത്തം, ഇൻവെൻ്ററി നിരീക്ഷണം, ലൊക്കേഷൻ അന്വേഷണം ​​എന്നിവ കൈകാര്യം ചെയ്യുന്നു.

3. വികസന окружение സജ്ജമാക്കുക

ഈ പ്രോജക്റ്റ് കാര്യക്ഷമമായ ഡിപൻഡൻസി മാനേജ്മെന്റിനായി Python uv ഉപയോഗിക്കുന്നു.

പ്രധാന ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുക

uv add langchain langchain-openai langgraph psycopg2-binary python-dotenv langchain-community

PostgreSQL എൻവയോൺമെൻ്റ് കോൺഫിഗറേഷൻ

ഒരു Postgres ഇൻസ്റ്റൻസ് പ്രാദേശികമായി ആരംഭിച്ച് agent_platform ഡാറ്റാബേസ് ഉണ്ടാക്കുക. ടേബിൾ ഘടനയും ടെസ്റ്റ് ഡാറ്റയും സ്വയമേവ സജ്ജീകരിക്കുന്നതിന് ഞങ്ങൾ setup_db.py സ്ക്രിപ്റ്റ് നൽകുന്നു (കൂടുതൽ വിവരങ്ങൾക്ക് ലേഖനത്തിന്റെ അവസാനം പരിശോധിക്കുക).

4. പ്രധാന നടപ്പാക്കൽ ഘട്ടങ്ങൾ### ഘട്ടം ഒന്ന്: ഡൊമെയ്ൻ വൈദഗ്ദ്ധ്യം നിർവ്വചിക്കുക (അറിവ്)

ഞങ്ങൾ വൈദഗ്ദ്ധ്യത്തെ ഒരു നിഘണ്ടു ഘടനയായി നിർവചിക്കുന്നു, ഫയൽ സിസ്റ്റത്തിൽ നിന്നോ ഡാറ്റാബേസിൽ നിന്നോ ലോഡ് ചെയ്യുന്ന പ്രക്രിയയെ അനുകരിക്കുന്നു. description (ഏജന്റ് തിരഞ്ഞെടുക്കുന്നതിന് ഉപയോഗപ്രദമാണ്), content (കൃത്യമായ വിശദമായ സന്ദർഭം) എന്നിവ തമ്മിൽ വേർതിരിക്കാൻ ശ്രദ്ധിക്കുക.

SKILLS = {"sales_analytics": {"description":"വിൽപ്പന വരുമാനം, ട്രെൻഡുകൾ എന്നിവ വിശകലനം ചെയ്യാൻ ഉപയോഗപ്രദം...","content":"""... Table Schema: sales_data ..."" },"inventory_management": {"description":"സ്റ്റോക്ക് ലെവലുകൾ പരിശോധിക്കാൻ ഉപയോഗപ്രദം...","content":"""... Table Schema: inventory_items ..."" }}

ഘട്ടം രണ്ട്: പ്രധാന ടൂളുകൾ നടപ്പിലാക്കുക (ശേഷികൾ)

ഒരു ടാസ്‌ക് പൂർത്തിയാക്കാൻ ഏജന്റ് രണ്ട് പ്രധാന ടൂളുകളെ ആശ്രയിക്കുന്നു:

• load_skill(skill_name): റൺടൈമിൽ നിർദ്ദിഷ്ട വൈദഗ്ദ്ധ്യത്തിന്റെ വിശദാംശങ്ങൾ ഡൈനാമിക് ആയി ലോഡ് ചെയ്യുന്നു.

• run_sql_query(query): നിർദ്ദിഷ്ട SQL സ്റ്റേറ്റ്മെന്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നു.

ഘട്ടം മൂന്ന്: ഏജന്റ് ലോജിക് ക്രമീകരിക്കുക (മസ്തിഷ്കം)

LangGraph ഉപയോഗിച്ച് ReAct ഏജന്റ് നിർമ്മിക്കുക. ഇവിടെ സിസ്റ്റം പ്രോംപ്റ്റ് ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു, ഇത് Identify -> Load -> Query എന്ന സ്റ്റാൻഡേർഡ് ഓപ്പറേറ്റിംഗ് നടപടിക്രമം (SOP) കർശനമായി പാലിക്കാൻ ഏജന്റിനെ നയിക്കുന്നു.

system_prompt ="""1. Identify the relevant skill.2. Use 'load_skill' to get schema.3. Write and execute SQL using 'run_sql_query'....Do not guess table names. Always load the skill first."""

5. പ്രവർത്തന ഫലങ്ങളുടെ സ്ഥിരീകരണം

test_agent.py പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ, ഞങ്ങൾ Sales, Inventory എന്നീ രണ്ട് വ്യത്യസ്ത ഡൊമെയ്‌നുകളിലെ ചോദ്യങ്ങൾ പരീക്ഷിച്ചു. ഏജന്റ് എങ്ങനെ പ്രശ്നത്തിനനുസരിച്ച് വൈദഗ്ദ്ധ്യം ഡൈനാമിക് ആയി ലോഡ് ചെയ്യുന്നു എന്ന് കാണിക്കുന്ന കൺസോളിന്റെ ഔട്ട്പുട്ട് ലോഗ് ഇതാ:

Testing Sales Query...Agent calling tools: [{'name': 'load_skill', 'args': {'skill_name': 'sales_analytics'}, 'id': 'call_f270d76b7ce4404cb5f61bf2', 'type': 'tool_call'}]Tool output:You are a Sales Analytics Expert.You have access to the 'sales_data' table.Table Schema:- id: integer...Agent calling tools: [{'name': 'run_sql_query', 'args': {'query': 'SELECT SUM(amount) as total_revenue FROM sales_data;'}, 'id': 'call_b4f3e686cc7f4f22b3bb9ea7', 'type': 'tool_call'}]Tool output: [(Decimal('730.50'),)]...Agent response: The total revenue is $730.50.Testing Inventory Query...Agent calling tools: [{'name': 'load_skill', 'args': {'skill_name': 'inventory_management'}, 'id': 'call_18c823b2d5064e95a0cfe2e3', 'type': 'tool_call'}]Tool output:You are an Inventory Management Expert.You have access to the 'inventory_items' table.Table Schema...Agent calling tools: [{'name': 'run_sql_query', 'args': {'query': "SELECT warehouse_location FROM inventory_items WHERE product_name = 'Laptop';"}, 'id': 'call_647ee3a444804bd98a045f00', 'type': 'tool_call'}]Tool output: [('Warehouse A',)]...Agent response: The Laptop is located in **Warehouse A**.## 6. സമ്പൂർണ്ണ സോഴ്സ് കോഡ് റഫറൻസ്

ഇവ താഴെ പറയുന്നവയാണ് പ്രോജക്റ്റിൻ്റെ പൂർണ്ണമായ സോഴ്സ് കോഡ്, ഡാറ്റാബേസ് ആരംഭിക്കുന്നതിനുള്ള സ്ക്രിപ്റ്റും ഏജൻ്റ് മെയിൻ പ്രോഗ്രാമും ഇതിൽ അടങ്ങിയിരിക്കുന്നു.

1. ഡാറ്റാബേസ് ആരംഭിക്കൽ (setup_db.py)

`import psycopg2 from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT import os from dotenv import load_dotenv

load_dotenv()

.env ഫയലിൽ ഡാറ്റാബേസ് കണക്ഷൻ വിവരങ്ങൾ ശരിയായി നൽകിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക

DB_HOST = os.getenv("DB_HOST", "localhost") DB_PORT = os.getenv("DB_PORT", "5432") DB_USER = os.getenv("DB_USER", "postgres") DB_PASSWORD = os.getenv("DB_PASSWORD", "your_password") # യഥാർത്ഥ പാസ്‌വേഡ് നൽകുക DB_NAME = os.getenv("DB_NAME", "agent_platform")

def create_database(): try: # പുതിയ ഡാറ്റാബേസ് ഉണ്ടാക്കാൻ 'postgres' എന്ന ഡിഫോൾട്ട് ഡാറ്റാബേസിലേക്ക് കണക്ട് ചെയ്യുക conn = psycopg2.connect( host=DB_HOST, port=DB_PORT, user=DB_USER, password=DB_PASSWORD, dbname="postgres", ) conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT) cur = conn.cursor()

    # ഡാറ്റാബേസ് നിലവിലുണ്ടോയെന്ന് പരിശോധിക്കുക
    cur.execute(f"SELECT 1 FROM pg_catalog.pg_database WHERE datname = '{DB_NAME}'")
    exists = cur.fetchone()

    if not exists:
        print(f"Creating database {DB_NAME}...")
        cur.execute(f"CREATE DATABASE {DB_NAME}")
    else:
        print(f"Database {DB_NAME} already exists.")

    cur.close()
    conn.close()

except Exception as e:
    print(f"Error creating database: {e}")

def create_tables_and_data(): try: conn = psycopg2.connect( host=DB_HOST, port=DB_PORT, user=DB_USER, password=DB_PASSWORD, dbname=DB_NAME, ) cur = conn.cursor()

    # Sales ടേബിൾ ഉണ്ടാക്കുക
    print("Creating sales_data table...")
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS sales_data (
            id SERIAL PRIMARY KEY,
            transaction_date DATE,
            product_id VARCHAR(50),
            amount DECIMAL(10, 2),
            region VARCHAR(50)
        )
        """
    )

    # Inventory ടേബിൾ ഉണ്ടാക്കുക
    print("Creating inventory_items table...")
    cur.execute(
        """
        CREATE TABLE IF NOT EXISTS inventory_items (
            id SERIAL PRIMARY KEY,
            product_id VARCHAR(50),
            product_name VARCHAR(100),
            stock_count INTEGER,
            warehouse_location VARCHAR(50)
        )
        """
    )

    # മോക്ക് ഡാറ്റ ചേർക്കുക
    print("Inserting mock data...")
    cur.execute("TRUNCATE sales_data, inventory_items")

    sales_data = [
        ('2023-01-01', 'P001', 100.00, 'North'),
        ('2023-01-02', 'P002', 150.50, 'South'),
        ('2023-01-03', 'P001', 120.00, 'East'),
        ('2023-01-04', 'P003', 200.00, 'West'),
        ('2023-01-05', 'P002', 160.00, 'North'),
    ]
    cur.executemany(
        "INSERT INTO sales_data (transaction_date, product_id, amount, region) VALUES (%s, %s, %s, %s)",
        sales_data,
    )

    inventory_data = [
        ('P001', 'Laptop', 50, 'Warehouse A'),
        ('P002', 'Mouse', 200, 'Warehouse B'),
        ('P003', 'Keyboard', 150, 'Warehouse A'),
        ('P004', 'Monitor', 30, 'Warehouse C'),
    ]
    cur.executemany(
        "INSERT INTO inventory_items (product_id, product_name, stock_count, warehouse_location) VALUES (%s, %s, %s, %s)",
        inventory_data,
    )

    conn.commit()
    cur.close()
    conn.close()
    print("Database setup complete.")

except Exception as e:
    print(f"Error setting up tables: {e}")

if name == "main": create_database() create_tables_and_data() `### 2. Agent പ്രധാന പ്രോഗ്രാം (main.py)

importosfromtypingimportAnnotated, Literal, TypedDict, Union, Dictfromdotenvimportload_dotenvfromlangchain_openaiimportChatOpenAIfromlangchain_core.toolsimporttoolfromlangchain_core.messagesimportSystemMessage, HumanMessage, AIMessage, ToolMessagefromlangchain_community.utilitiesimportSQLDatabasefromlangchain_community.agent_toolkitsimportSQLDatabaseToolkitfromlanggraph.graphimportStateGraph, START, END, MessagesStatefromlanggraph.prebuiltimportToolNode, tools_conditionload_dotenv()# --- Configuration ---BASE_URL = os.getenv("BASIC_MODEL_BASE_URL")API_KEY = os.getenv("BASIC_MODEL_API_KEY")MODEL_NAME = os.getenv("BASIC_MODEL_MODEL")DB_URI =f"postgresql://{os.getenv('DB_USER')}:{os.getenv('DB_PASSWORD')}@{os.getenv('DB_HOST')}:{os.getenv('DB_PORT')}/{os.getenv('DB_NAME')}"# --- Database Setup ---db = SQLDatabase.from_uri(DB_URI)# --- Skills Definition ---SKILLS: Dict[str, Dict[str, str]] = {"sales_analytics": {"description":"വിൽപ്പന വരുമാനം, ട്രെൻഡുകൾ, പ്രാദേശിക പ്രകടനം എന്നിവ വിശകലനം ചെയ്യാൻ ഉപയോഗപ്രദമാണ്.","content":"""നിങ്ങൾ ഒരു സെയിൽസ് അനലിറ്റിക്സ് വിദഗ്ദ്ധനാണ്.'sales_data' എന്ന ടേബിളിലേക്ക് നിങ്ങൾക്ക് ആക്സസ് ഉണ്ട്.Table Schema:- id: integer (primary key)- transaction_date: date- product_id: varchar(50)- amount: decimal(10, 2)- region: varchar(50)Common queries:- Total revenue: SUM(amount)- Revenue by region: GROUP BY region- Sales trend: GROUP BY transaction_date""" },"inventory_management": {"description":"സ്റ്റോക്ക് ലെവലുകൾ, ഉൽപ്പന്ന ലൊക്കേഷനുകൾ, വെയർഹൗസ് മാനേജ്മെൻ്റ് എന്നിവ പരിശോധിക്കാൻ ഉപയോഗപ്രദമാണ്.","content":"""നിങ്ങൾ ഒരു ഇൻവെൻ്ററി മാനേജ്മെൻ്റ് വിദഗ്ദ്ധനാണ്. 'inventory_items' table.Table Schema:- id: integer (primary key)- product_id: varchar(50)- product_name: varchar(100)- stock_count: integer- warehouse_location: varchar(50)Common queries:- Check stock: WHERE product_name = '...'- Low stock: WHERE stock_count < threshold""" }}# --- Tools ---@tooldefload_skill(skill_name: str)-> str:""" Load the detailed prompt and schema for a specific skill. Available skills: - sales_analytics: For sales, revenue, and transaction analysis. - inventory_management: For stock, products, and warehouse queries. """ skill = SKILLS.get(skill_name)ifnotskill:returnf"Error: Skill '{skill_name}' not found. Available skills:{list(SKILLS.keys())}"returnskill["content"]@tooldefrun_sql_query(query: str)-> str:""" Execute a SQL query against the database. Only use this tool AFTER loading the appropriate skill to understand the schema. """try:returndb.run(query)exceptExceptionase:returnf"Error executing SQL:{e}"@tooldeflist_tables()-> str:"""List all available tables in the database."""returnstr(db.get_usable_table_names())tools = [load_skill, run_sql_query, list_tables]# --- Agent Setup ---llm = ChatOpenAI( base_url=BASE_URL, api_key=API_KEY, model=MODEL_NAME, temperature=0)llm_with_tools = llm.bind_tools(tools)# --- Graph Definition ---classAgentState(MessagesState):# We can add custom state if needed, but MessagesState is sufficient for simple chatpassdefagent_node(state: AgentState): messages = state["messages"] response = llm_with_tools.invoke(messages)return{"messages": [response]}workflow = StateGraph(AgentState)workflow.add_node("agent", agent_node)workflow.add_node("tools", ToolNode(tools))workflow.add_edge(START,"agent")workflow.add_conditional_edges("agent", tools_condition)workflow.add_edge("tools","agent")app = workflow.compile()# --- Main Execution ---if__name__ =="__main__": system_prompt ="""നിങ്ങളൊരു സഹായകരമായ SQL അസിസ്റ്റന്റാണ്. ഡാറ്റാബേസ് സ്കീമകളും ഡൊമെയ്ൻ പരിജ്ഞാനവും അടങ്ങിയ പ്രത്യേക കഴിവുകൾ നിങ്ങൾക്കുണ്ട്. ഒരു ഉപയോക്താവിൻ്റെ ചോദ്യത്തിന് ഉത്തരം നൽകാൻ: 1. പ്രസക്തമായ വൈദഗ്ദ്ധ്യം (sales_analytics അല്ലെങ്കിൽ inventory_management) തിരിച്ചറിയുക. 2. സ്കീമയും നിർദ്ദേശങ്ങളും നേടുന്നതിന് 'load_skill' ടൂൾ ഉപയോഗിക്കുക. 3. ലോഡ് ചെയ്ത വൈദഗ്ദ്ധ്യത്തെ അടിസ്ഥാനമാക്കി, 'run_sql_query' ഉപയോഗിച്ച് ഒരു SQL ചോദ്യം എഴുതി എക്സിക്യൂട്ട് ചെയ്യുക. 4. ചോദ്യത്തിൻ്റെ ഫലങ്ങളെ അടിസ്ഥാനമാക്കി ഉപയോക്താവിൻ്റെ ചോദ്യത്തിന് ഉത്തരം നൽകുക. പട്ടികകളുടെ പേരുകൾ ഊഹിക്കരുത്. എല്ലായ്പ്പോഴും ആദ്യം വൈദഗ്ദ്ധ്യം ലോഡ് ചെയ്യുക.""" print("SQL അസിസ്റ്റന്റ് ആരംഭിച്ചു. പുറത്തുകടക്കാൻ 'quit' എന്ന് ടൈപ്പ് ചെയ്യുക.") print("-"*50) messages = [SystemMessage(content=system_prompt)]# കണക്ഷൻ പരിശോധന മുൻകൂട്ടി തയ്യാറാക്കുകtry: print(f"ഡാറ്റാബേസിലേക്ക് കണക്റ്റുചെയ്തു:{DB_URI.split('@')[-1]}")exceptExceptionase: print(f"ഡാറ്റാബേസ് കണക്ഷൻ മുന്നറിയിപ്പ്:{e}")whileTrue:try: user_input = input("ഉപയോക്താവ്: ")ifuser_input.lower()in["quit","exit"]:break messages.append(HumanMessage(content=user_input))# എക്സിക്യൂഷൻ സ്ട്രീം ചെയ്യുക print("ഏജന്റ്: ", end="", flush=True) final_response =Noneforeventinapp.stream({"messages": messages}, stream_mode="values"):# 'values' മോഡിൽ, ഞങ്ങൾക്ക് പൂർണ്ണമായ അവസ്ഥ ലഭിക്കും. പുതിയതാണെങ്കിൽ അവസാന സന്ദേശം കാണാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. last_message = event["messages"][-1]# ഏറ്റവും പുതിയ അവസ്ഥ ഉപയോഗിച്ച് ഞങ്ങളുടെ സന്ദേശ ചരിത്രം അപ്‌ഡേറ്റ് ചെയ്യുകpass# സ്ട്രീം പൂർത്തിയായ ശേഷം, അവസാന അവസ്ഥയിൽ അവസാന ഉത്തരം ഉണ്ടാകും final_state = app.invoke({"messages": messages}) last_msg = final_state["messages"][-1]ifisinstance(last_msg, AIMessage): print(last_msg.content) messages = final_state["messages"]# Update history print("-"*50)exceptExceptionase: print(f"\nError:{e}")break