ਵੱਡੇ ਭਾਸ਼ਾ ਮਾਡਲਾਂ (LLMs) ਵਿੱਚ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ: ਇੱਕ ਵਿਸਤ੍ਰਿਤ ਵਿਸ਼ਲੇਸ਼ਣ

ਪਰਿਚਯ

ਵੱਡੇ ਭਾਸ਼ਾ ਮਾਡਲਾਂ (LLMs) ਜਿਵੇਂ ਕਿ GPT-4, Claude, ਅਤੇ PaLM ਨੇ ਕੁਦਰਤੀ ਭਾਸ਼ਾ ਪ੍ਰਕਿਰਿਆ (NLP) ਵਿੱਚ ਕ੍ਰਾਂਤੀ ਲਿਆਉਣੀ ਹੈ, ਜਿਸ ਨਾਲ ਮਸ਼ੀਨਾਂ ਨੂੰ ਮਨੁੱਖੀ-ਵਾਂਗ ਟੈਕਸਟ ਨੂੰ ਸਮਝਣ ਅਤੇ ਤਿਆਰ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਮਿਲੀ ਹੈ। ਹਾਲੀਆ LLM ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਸਭ ਤੋਂ ਬਦਲਾਅਕਾਰੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ—ਇੱਕ LLM ਵੱਲੋਂ ਯੂਜ਼ਰ ਦੀ ਨੀਅਤ ਅਨੁਸਾਰ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਨੂੰ ਪਛਾਣਣ, ਢਾਂਚਾਬੱਧ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ। ਇਹ ਨਵੀਨਤਾ LLMs ਨੂੰ ਬਾਹਰੀ ਟੂਲਾਂ, API, ਅਤੇ ਡੇਟਾਬੇਸ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਯੋਗ ਬਣਾਉਂਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਇਹ ਸਿਰਫ਼ ਟੈਕਸਟ ਜਨਰੇਸ਼ਨ ਤੋਂ ਕਿਤੇ ਵੱਧ ਸਮਰੱਥ ਹੋ ਜਾਂਦੇ ਹਨ।

ਇਹ ਲੇਖ LLMs ਵਿੱਚ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ ਦੇ ਸੰਕਲਪ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਨੂੰ ਪੇਸ਼ ਕਰਨ ਦੇ ਤਰੀਕੇ: ਪਲੇਨਟੈਕਸਟ (ਉਦਾਹਰਨ ਵਜੋਂ, <arg1>value</arg1>), JSON, ਅਤੇ ਹੋਰ ਤਕਨੀਕੀ ਪਰੋਟੋਕੋਲ ਜਿਵੇਂ ਕਿ MCP (ਮੇਸੇਜ ਕੰਟਰੋਲ ਪਰੋਟੋਕੋਲ) ਅਤੇ A2A (ਏਜੰਟ-ਤੂ-ਏਜੰਟ)। ਅਸੀਂ ਉਨ੍ਹਾਂ ਦੀਆਂ ਮਜ਼ਬੂਤੀਆਂ, ਕਮਜ਼ੋਰੀਆਂ, ਅਤੇ ਵੱਖ-ਵੱਖ ਵਰਤੋਂ ਮਾਮਲਿਆਂ ਲਈ ਉਪਯੋਗਤਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਾਂਗੇ, ਕੋਡ ਉਦਾਹਰਨਾਂ ਅਤੇ ਵਿਹਾਰਕ ਜਾਣਕਾਰੀਆਂ ਦੇ ਨਾਲ।

1. LLMs ਵਿੱਚ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ ਨੂੰ ਸਮਝਣਾ

LLMs ਵਿੱਚ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ ਦਾ ਮਤਲਬ ਮਾਡਲ ਦੀ ਇਹ ਸਮਰੱਥਾ ਹੈ ਕਿ ਉਹ:

• ਯੂਜ਼ਰ ਦੀ ਨੀਅਤ ਨੂੰ ਸਮਝ ਸਕੇ (ਉਦਾਹਰਨ ਵਜੋਂ, "ਪੈਰਿਸ ਵਿੱਚ ਮੌਸਮ ਕਿਹੋ ਜਿਹਾ ਹੈ?")
• ਨੀਅਤ ਨੂੰ ਫੰਕਸ਼ਨ ਸਿਗਨੇਚਰ ਨਾਲ ਜੋੜ ਸਕੇ (ਉਦਾਹਰਨ ਵਜੋਂ, get_weather(location: str))
• ਆਰਗੂਮੈਂਟ ਨਿਕਾਲ ਕੇ ਢਾਂਚਾਬੱਧ ਕਰ ਸਕੇ (ਉਦਾਹਰਨ ਵਜੋਂ, location = "Paris")
• ਫੰਕਸ਼ਨ ਕਾਲ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਫਾਰਮੈਟ ਕਰ ਸਕੇ ਕਿ ਬਾਹਰੀ ਸਿਸਟਮ ਉਸਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰ ਸਕਣ
• ਨਤੀਜੇ ਵਾਪਸ ਕਰਕੇ ਗੱਲਬਾਤ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰ ਸਕੇ

ਇਹ ਪ੍ਰਕਿਰਿਆ ਲਈ ਨਾ ਸਿਰਫ਼ ਭਾਸ਼ਾ ਦੀ ਸਮਝ, ਸਗੋਂ ਢਾਂਚਾਬੱਧ ਤਰਕ ਅਤੇ ਖਾਸ ਡੇਟਾ ਫਾਰਮੈਟਾਂ ਦੀ ਪਾਲਣਾ ਵੀ ਲਾਜ਼ਮੀ ਹੈ।

2. ਪਲੇਨਟੈਕਸਟ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ

2.1. ਵਰਣਨ

ਪਲੇਨਟੈਕਸਟ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ ਵਿੱਚ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਆਰਗੂਮੈਂਟ ਨੂੰ ਮਨੁੱਖੀ ਪੜ੍ਹਨ ਯੋਗ, ਅਕਸਰ ਮਾਰਕਅੱਪ-ਵਾਂਗ ਫਾਰਮੈਟ ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ:

<arg1>ਪੈਰਿਸ</arg1>
<arg2>2024-06-10</arg2>

ਜਾਂ, ਇੱਕ ਪੂਰੇ ਫੰਕਸ਼ਨ ਕਾਲ ਵਜੋਂ:
ਸਧਾਰਣ ਪਾਠ <function>get_weather</function> <location>ਪੈਰਿਸ</location> <date>2024-06-10</date>

2.2. ਫਾਇਦੇ

• ਇਨਸਾਨੀ ਪੜ੍ਹਨਯੋਗ: ਇਨਸਾਨਾਂ ਲਈ ਪੜ੍ਹਨਾ ਅਤੇ ਸਮਝਣਾ ਆਸਾਨ।
• ਲਾਗੂ ਕਰਨਾ ਆਸਾਨ: ਪੇਚੀਦੇ ਡਾਟਾ ਸਟ੍ਰਕਚਰ ਪਾਰਸ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ।
• ਲਚਕੀਲਾ: ਤੇਜ਼ ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ ਲਈ ਅਨੁਕੂਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

2.3. ਨੁਕਸਾਨ

• ਅਸਪਸ਼ਟਤਾ: ਸਖ਼ਤ ਸਕੀਮਾ ਦੀ ਘਾਟ ਕਾਰਨ ਗਲਤ ਸਮਝ ਹੋ ਸਕਦੀ ਹੈ।
• ਪਾਰਸ ਕਰਨ ਦੀ ਜਟਿਲਤਾ: ਡਾਟਾ ਕੱਢਣ ਲਈ ਕਸਟਮ ਪਾਰਸਰ ਦੀ ਲੋੜ।
• ਗਲਤੀਆਂ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ: ਸਕੀਮਾ ਦੇ ਮੁਕਾਬਲੇ ਕੋਈ ਵੈਧਤਾ ਨਹੀਂ; ਟਾਈਪੋ ਜਾਂ ਟੈਗ ਨਾ ਹੋਣ ਨਾਲ ਪ੍ਰਕਿਰਿਆ ਰੁਕ ਸਕਦੀ ਹੈ।

2.4. ਉਦਾਹਰਨ

ਮੰਨੋ ਇੱਕ ਯੂਜ਼ਰ ਪੁੱਛਦਾ ਹੈ: "ਨਿਊਯਾਰਕ ਤੋਂ ਲੰਡਨ ਜੁਲਾਈ 1 ਨੂੰ ਉਡਾਣ ਬੁੱਕ ਕਰੋ।"

LLM ਇਹ ਆਉਟਪੁਟ ਕਰ ਸਕਦਾ ਹੈ:

<function>book_flight</function>
<from>New York</from>
<to>London</to>
<date>2024-07-01</date>

ਇੱਕ ਬੈਕਐਂਡ ਸਿਸਟਮ ਨੂੰ ਇਸ ਆਉਟਪੁੱਟ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ, ਮੁੱਲਾਂ ਨੂੰ ਕੱਢਣਾ ਹੋਵੇਗਾ, ਅਤੇ ਸੰਬੰਧਤ ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣਾ ਹੋਵੇਗਾ।

3. JSON-ਅਧਾਰਤ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ

3.1. ਵੇਰਵਾ

JSON (JavaScript Object Notation) ਇੱਕ ਹਲਕਾ, ਵਿਆਪਕ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਡਾਟਾ ਇੰਟਰਚੇਂਜ ਫਾਰਮੈਟ ਹੈ। ਕਈ LLMs, ਜਿਵੇਂ ਕਿ OpenAI ਦਾ GPT-4, ਹੁਣ ਸਟਰੱਕਚਰਡ JSON ਆਉਟਪੁੱਟ ਵਰਤ ਕੇ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ ਨੂੰ ਸਹਾਇਤਾ ਦਿੰਦੇ ਹਨ।

ਉਦਾਹਰਨ:

{
  "function": "book_flight",
  "arguments": {
    "from": "ਨਿਊਯਾਰਕ",
    "to": "ਲੰਡਨ",
    "date": "2024-07-01"
  }
}

3.2. ਫਾਇਦੇ

• ਮਸ਼ੀਨ ਪੜ੍ਹਨਯੋਗ: ਲਗਭਗ ਸਾਰੇ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਲੋਂ ਆਸਾਨੀ ਨਾਲ ਪਾਰਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
• ਸਕੀਮਾ ਵੈਰੀਫਿਕੇਸ਼ਨ: ਆਰਗੂਮੈਂਟ ਕਿਸਮਾਂ ਅਤੇ ਲਾਜ਼ਮੀ ਖੇਤਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦਾ ਹੈ।
• ਮਿਆਰੀਕ੍ਰਿਤ: API ਅਤੇ ਡੇਟਾ ਅਦਾਨ-ਪ੍ਰਦਾਨ ਵਿੱਚ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਅਪਣਾਇਆ ਗਿਆ।

3.3. ਨੁਕਸਾਨ

• ਘੱਟ ਮਨੁੱਖ-ਮਿੱਤਰ: ਗੈਰ-ਤਕਨੀਕੀ ਵਰਤੋਂਕਾਰਾਂ ਲਈ ਪਲੇਨਟੈਕਸਟ ਵਾਂਗ ਪੜ੍ਹਨਯੋਗ ਨਹੀਂ।
• ਵਧੂ ਲੰਬਾ: ਸਧਾਰਣ ਕਾਲਾਂ ਲਈ ਲੋੜ ਤੋਂ ਵੱਧ ਲੰਬਾ ਹੋ ਸਕਦਾ ਹੈ।
• ਸਖ਼ਤ ਫਾਰਮੈਟਿੰਗ ਦੀ ਲੋੜ: ਛੋਟੀਆਂ ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ (ਜਿਵੇਂ ਕਿ ਕਾਮਾ ਗੁੰਮ ਹੋਣਾ) ਪਾਰਸਿੰਗ ਨੂੰ ਤੋੜ ਸਕਦੀਆਂ ਹਨ।

3.4. ਉਦਾਹਰਨ

ਵਰਤੋਂਕਾਰ ਦੀ ਪੁੱਛਗਿੱਛ: "ਕੱਲ੍ਹ ਸਵੇਰੇ 9 ਵਜੇ ਲਈ ਇੱਕ ਯਾਦ ਦਿਵਾਓ।"

LLM ਨਤੀਜਾ:

{
  "function": "set_reminder",
  "arguments": {
    "time": "2024-06-11T09:00:00",
    "note": "ਯਾਦ ਦਿਵਾਉਣ ਵਾਲਾ"
  }
}

ਇੱਕ ਬੈਕਐਂਡ ਇਸ JSON ਨੂੰ ਸਿੱਧਾ ਪਾਰਸ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ set_reminder ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ।

4. MCP (ਮੇਸੇਜ ਕੰਟਰੋਲ ਪ੍ਰੋਟੋਕੋਲ) ਅਤੇ A2A (ਏਜੰਟ-ਟੂ-ਏਜੰਟ) ਤਰੀਕੇ

4.1. ਵੇਰਵਾ

MCP ਅਤੇ A2A ਹੋਰ ਉੱਨਤ ਪ੍ਰੋਟੋਕੋਲ ਹਨ ਜੋ ਸੰਰਚਿਤ, ਬਹੁ-ਏਜੰਟ ਸੰਚਾਰ ਅਤੇ ਆਰਕੈਸਟਰੈਸ਼ਨ ਲਈ ਬਣਾਏ ਗਏ ਹਨ। ਇਹ ਅਕਸਰ ਉਹਨਾਂ ਮਾਹੌਲਾਂ ਵਿੱਚ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਜਿੱਥੇ ਕਈ ਏਜੰਟ (LLMs, ਟੂਲ, API) ਆਪਸ ਵਿੱਚ ਸੰਪਰਕ ਕਰਦੇ, ਸਹਿਯੋਗ ਕਰਦੇ ਜਾਂ ਕੰਮ ਸੌਂਪਦੇ ਹਨ।

MCP ਉਦਾਹਰਨ

MCP ਸੁਨੇਹੇ ਅਕਸਰ ਮਿਆਰੀ ਲਿਫਾਫੇ, ਮੈਟਾਡੇਟਾ, ਭੇਜਣ ਵਾਲੇ/ਪ੍ਰਾਪਤਕਰਤਾ ID ਅਤੇ ਪੇਲੋਡ ਵਰਗੇ ਹਿੱਸਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।

{
  "protocol": "MCP",
  "message_id": "abc123",
  "sender": "LLM_Agent_1",
  "receiver": "FlightBookingService",
  "timestamp": "2024-06-10T15:00:00Z",
  "payload": {
    "function": "book_flight",
    "arguments": {
      "from": "ਨਿਊਯਾਰਕ",
      "to": "ਲੰਡਨ",
      "date": "2024-07-01"
    }
  }
}

A2A ਉਦਾਹਰਨ

A2A ਪਰੋਟੋਕਾਲਾਂ ਵਿੱਚ ਵਾਧੂ ਸੰਦਰਭ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਗੱਲਬਾਤ ਦਾ ਇਤਿਹਾਸ, ਇਰਾਦਾ, ਜਾਂ ਕਈ ਕਦਮਾਂ ਵਾਲੇ ਵਰਕਫਲੋ।

{
  "protocol": "A2A",
  "conversation_id": "conv456",
  "step": 3,
  "intent": "ਉਡਾਣ ਬੁੱਕ ਕਰੋ",
  "agent": "LLM_Agent_1",
  "target_agent": "FlightBookingService",
  "parameters": {
    "from": "ਨਿਊਯਾਰਕ",
    "to": "ਲੰਡਨ",
    "date": "2024-07-01"
  },
  "context": {
    "previous_steps": [
      {"step": 1, "action": "ਵਰਤੋਂਕਾਰ ਨੂੰ ਪੁੱਛੋ", "result": "ਵਰਤੋਂਕਾਰ ਉਡਾਣ ਬੁੱਕ ਕਰਵਾਉਣਾ ਚਾਹੁੰਦਾ ਹੈ"},
      {"step": 2, "action": "ਵੇਰਵੇ ਲਵੋ", "result": "ਨਿਊਯਾਰਕ ਤੋਂ ਲੰਡਨ"}
    ]
  }
}

4.2. ਫਾਇਦੇ

• ਅਮੀਰ ਮੈਟਾਡਾਟਾ: ਪੇਚੀਦੇ ਵਰਕਫਲੋ, ਬਹੁ-ਏਜੰਟ ਆਰਕਿਸਟ੍ਰੇਸ਼ਨ, ਅਤੇ ਟਰੇਸਬਿਲਟੀ ਲਈ ਸਹਾਇਕ।
• ਸਕੇਲਬਿਲਟੀ: ਵੱਡੇ ਸਿਸਟਮਾਂ ਲਈ ਉਚਿਤ ਜਿੱਥੇ ਕਈ ਕੰਪੋਨੈਂਟ ਆਪਸ ਵਿੱਚ ਕਿਰਿਆਸ਼ੀਲ ਹਨ।
• ਵਧਾਊਗਤਾ: ਲੋੜ ਮੁਤਾਬਕ ਨਵੇਂ ਖੇਤਰ (ਜਿਵੇਂ ਕਿ ਸੁਰੱਖਿਆ, ਲਾਗਿੰਗ) ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ।

4.3. ਨੁਕਸਾਨ

• ਪੇਚੀਦਗੀ: ਲਾਗੂ ਕਰਨ ਅਤੇ ਰੱਖ-ਰਖਾਵ ਕਰਨ ਵਿੱਚ ਔਖਾ।
• ਓਵਰਹੈੱਡ: ਵਾਧੂ ਮੈਟਾਡਾਟਾ ਕਾਰਨ ਸੁਨੇਹੇ ਦਾ ਆਕਾਰ ਵੱਧ ਜਾਂਦਾ ਹੈ।
• ਸਖਤ ਪਾਲਣਾ ਦੀ ਲੋੜ: ਸਾਰੇ ਏਜੰਟਾਂ ਨੂੰ ਪਰੋਟੋਕੋਲ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨੀ ਪੈਂਦੀ ਹੈ।

5. ਤੁਲਨਾਤਮਕ ਵਿਸ਼ਲੇਸ਼ਣ

ਵਿਸ਼ੇਸ਼ਤਾ	ਪਲੇਨਟੈਕਸਟ (<arg1>value</arg1>)	JSON	MCP/A2A
ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗਤਾ	ਉੱਚ	ਦਰਮਿਆਨਾ	ਘੱਟ
ਮਸ਼ੀਨ ਪੜ੍ਹਨਯੋਗਤਾ	ਘੱਟ/ਦਰਮਿਆਨਾ (ਪਾਰਸਿੰਗ ਦੀ ਲੋੜ)	ਉੱਚ	ਉੱਚ
ਸਕੀਮਾ ਵੈਰੀਫਿਕੇਸ਼ਨ	ਘੱਟ	ਉੱਚ	ਉੱਚ
ਵਧਾਊਗਤਾ	ਘੱਟ	ਦਰਮਿਆਨਾ	ਉੱਚ
ਪੇਚੀਦਗੀ	ਘੱਟ	ਦਰਮਿਆਨਾ	ਉੱਚ
ਵਰਤੋਂ ਕੇਸ	ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ, ਸਧਾਰਨ ਐਪਸ	ਪ੍ਰੋਡਕਸ਼ਨ API, LLM ਟੂਲ	ਬਹੁ-ਏਜੰਟ, ਆਰਕਿਸਟ੍ਰੇਸ਼ਨ

5.1. ਹਰ ਤਰੀਕੇ ਨੂੰ ਕਦੋਂ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ

• ਪਲੇਨਟੈਕਸਟ: ਤੇਜ਼ ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ, ਡੈਮੋ ਜਾਂ ਜਦੋਂ ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗਤਾ ਸਭ ਤੋਂ ਵਧੀਆ ਹੋਵੇ।
• JSON: ਪ੍ਰੋਡਕਸ਼ਨ ਸਿਸਟਮਾਂ, API, ਜਾਂ ਜਦੋਂ ਆਧੁਨਿਕ LLMs ਨਾਲ ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਕਰਨਾ ਹੋਵੇ ਜੋ ਸੰਰਚਿਤ ਨਤੀਜੇ ਸਮਝ ਸਕਦੇ ਹਨ।
• MCP/A2A: ਪੇਚੀਦੇ, ਬਹੁ-ਏਜੰਟ ਸਿਸਟਮਾਂ ਲਈ ਜਿੱਥੇ ਟਰੇਸਬਿਲਟੀ, ਮੈਟਾਡਾਟਾ ਅਤੇ ਆਰਕਿਸਟ੍ਰੇਸ਼ਨ ਦੀ ਲੋੜ ਹੋਵੇ।

6. ਵਿਹਾਰਕ ਵਿਚਾਰ

6.1. LLM ਪ੍ਰਾਂਪਟ ਇੰਜੀਨੀਅਰਿੰਗ

ਤੁਸੀਂ LLM ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਂਪਟ ਕਰਦੇ ਹੋ, ਇਹ ਨਤੀਜੇ ਦੇ ਫਾਰਮੈਟ ਨੂੰ ਬਹੁਤ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, JSON ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ:

ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ-ਕਾਲਿੰਗ ਸਹਾਇਕ ਹੋ। ਜਦੋਂ ਤੁਹਾਨੂੰ ਕੋਈ ਸਵਾਲ ਪੁੱਛਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ JSON ਆਬਜੈਕਟ ਦੇ ਨਾਲ ਜਵਾਬ ਦਿਓ ਜਿਸ ਵਿੱਚ ਫੰਕਸ਼ਨ ਅਤੇ ਉਸਦੇ ਆਰਗੂਮੈਂਟ ਦਿੱਤੇ ਹੋਣ।

ਪਲੇਨਟੈਕਸਟ ਲਈ:

ਫੰਕਸ਼ਨ ਆਰਗਯੂਮੈਂਟਸ ਨੂੰ ਇਸ ਫਾਰਮੈਟ ਵਿੱਚ ਜਵਾਬ ਦਿਓ: <arg1>ਮੁੱਲ</arg1>

6.2. ਗਲਤੀ ਸੰਭਾਲਣਾ

• ਪਲੇਨਟੈਕਸਟ: ਗਲਤੀਆਂ ਪਛਾਣਣੀਆਂ ਔਖੀਆਂ ਹੁੰਦੀਆਂ ਹਨ; ਗੁੰਮ ਟੈਗ ਜਾਂ ਗਲਤ ਬਣਿਆ ਟੈਕਸਟ ਅਣਦੇਖਾ ਰਹਿ ਸਕਦਾ ਹੈ।
• JSON: ਪਾਰਸਰ ਸਿੰਟੈਕਸ ਗਲਤੀਆਂ ਫੜ ਸਕਦੇ ਹਨ, ਪਰ LLM ਅਜੇ ਵੀ ਗਲਤ JSON ਬਣਾਉਣ ਦੀ ਭੁੱਲ ਕਰ ਸਕਦੇ ਹਨ।
• MCP/A2A: ਪਰੋਟੋਕੋਲ ਆਮ ਤੌਰ 'ਤੇ ਗਲਤੀ ਵਾਲੇ ਖੇਤਰ ਅਤੇ ਸਥਿਤੀ ਕੋਡ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਮਜ਼ਬੂਤ ਸੰਭਾਲ ਹੋ ਸਕਦੀ ਹੈ।

6.3. ਸੁਰੱਖਿਆ

• ਪਲੇਨਟੈਕਸਟ: ਇੰਜੈਕਸ਼ਨ ਹਮਲਿਆਂ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸਰਦਾਰ।
• JSON: ਵੈਧਤਾ ਅਤੇ ਸਾਫ-ਸਫਾਈ ਲਾਗੂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
• MCP/A2A: ਪਰਮਾਣਿਕਤਾ, ਅਧਿਕਾਰ ਅਤੇ ਇੰਕ੍ਰਿਪਸ਼ਨ ਖੇਤਰ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

7. ਕੋਡ ਉਦਾਹਰਨਾਂ

7.1. ਪਲੇਨਟੈਕਸਟ ਨੂੰ Python ਵਿੱਚ ਪਾਰਸ ਕਰਨਾ

import re

# ਸਧਾਰਣ ਟੈਕਸਟ ਨੂੰ ਪਾਰਸ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ
def parse_plaintext(text):
    pattern = r"<(\w+)>(.*?)</\1>"
    return {match[0]: match[1] for match in re.findall(pattern, text)}

text = "<function>book_flight</function><from>New York</from><to>London</to><date>2024-07-01</date>"
print(parse_plaintext(text))
# ਆਉਟਪੁੱਟ: {'function': 'book_flight', 'from': 'New York', 'to': 'London', 'date': '2024-07-01'}

7.2. ਪਾਇਥਨ ਵਿੱਚ JSON ਪਾਰਸ ਕਰਨਾ

import json

def parse_json(json_str):
    return json.loads(json_str)

json_str = '''
{
  "function": "book_flight",
  "arguments": {
    "from": "New York",
    "to": "London",
    "date": "2024-07-01"
  }
}
'''
print(parse_json(json_str))

7.3. MCP/A2A ਸੁਨੇਹਿਆਂ ਨੂੰ ਹੈਂਡਲ ਕਰਨਾ

def handle_mcp_message(message):
    payload = message.get("payload", {})
    function = payload.get("function")
    arguments = payload.get("arguments", {})
    # ਕੱਢੇ ਗਏ ਡਾਟਾ ਦੇ ਆਧਾਰ 'ਤੇ ਫੰਕਸ਼ਨ ਚਲਾਓ
    # ...

mcp_message = {
    "protocol": "MCP",
    "message_id": "abc123",
    "sender": "LLM_Agent_1",
    "receiver": "FlightBookingService",
    "timestamp": "2024-06-10T15:00:00Z",
    "payload": {
        "function": "book_flight",
        "arguments": {
            "from": "New York",
            "to": "London",
            "date": "2024-07-01"
        }
    }
}
handle_mcp_message(mcp_message)

8. ਭਵਿੱਖ ਦੇ ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼

ਜਿਵੇਂ-जਿਵੇਂ LLMs ਸਾਫਟਵੇਅਰ ਸਿਸਟਮਾਂ ਵਿੱਚ ਹੋਰ ਗਹਿਰਾਈ ਨਾਲ ਸ਼ਾਮਲ ਹੁੰਦੇ ਜਾ ਰਹੇ ਹਨ, ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ ਵੀ ਵਿਕਸਤ ਹੁੰਦੀ ਰਹੇਗੀ। ਮੁੱਖ ਰੁਝਾਨਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ਮਿਆਰੀਕਰਨ: LLM ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ ਲਈ ਯੂਨੀਵਰਸਲ ਸਕੀਮਾਂ ਅਤੇ ਪ੍ਰੋਟੋਕੋਲਾਂ ਦਾ ਉਭਾਰ।
• ਟੂਲ ਦੀ ਵਰਤੋਂ: LLMs ਦੁਆਰਾ ਬਾਹਰੀ ਟੂਲਾਂ ਦੀ ਖੁਦਮੁਖਤਿਆਰ ਚੋਣ ਅਤੇ ਵਰਤੋਂ।
• ਮਲਟੀ-ਏਜੰਟ ਸਹਿਯੋਗ: LLMs ਵੱਲੋਂ ਹੋਰ ਏਜੰਟਾਂ, APIs, ਅਤੇ ਸਰਵਿਸਿਜ਼ ਨਾਲ ਮਿਲ ਕੇ ਕੰਮ ਕਰਨਾ।
• ਸੁਰੱਖਿਆ ਅਤੇ ਗਵਰਨੈਂਸ: ਪਰਮਾਣਕਿਤਾ, ਅਧਿਕਾਰ ਅਤੇ ਆਡੀਟਿੰਗ ਲਈ ਵਧੀਆ ਕੰਟਰੋਲ।

ਨਤੀਜਾ

LLMs ਵਿੱਚ ਫੰਕਸ਼ਨ ਕਾਲਿੰਗ AI ਸਮਰੱਥਾਵਾਂ ਵਿੱਚ ਇੱਕ ਵੱਡੀ ਛਾਲ ਹੈ, ਜੋ ਮਾਡਲਾਂ ਨੂੰ ਵਿਅਕਤੀਗਤ, ਪ੍ਰੋਗ੍ਰਾਮੇਬਲ ਢੰਗ ਨਾਲ ਦੁਨੀਆ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਯੋਗ ਬਣਾਉਂਦੀ ਹੈ। ਨੁਮਾਇੰਦਗੀ ਦੀ ਚੋਣ—ਪਲੇਨਟੈਕਸਟ, JSON, ਜਾਂ ਤਕਨੀਕੀ ਪ੍ਰੋਟੋਕੋਲ ਜਿਵੇਂ MCP/A2A—ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ ਲੋੜਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਮਨੁੱਖੀ ਪੜ੍ਹਨਯੋਗਤਾ, ਮਸ਼ੀਨ ਪਾਰਸਿੰਗ, ਵਿਸਥਾਰਯੋਗਤਾ ਅਤੇ ਜਟਿਲਤਾ ਦਾ ਸੰਤੁਲਨ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।

• ਪਲੇਨਟੈਕਸਟ ਸਧਾਰਣ, ਮਨੁੱਖ-ਕੇਂਦਰਤ ਕੰਮਾਂ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਹੈ।
• JSON ਮਜ਼ਬੂਤ, ਮਸ਼ੀਨ-ਟੂ-ਮਸ਼ੀਨ ਸੰਚਾਰ ਲਈ ਮੌਜੂਦਾ ਮਿਆਰ ਹੈ।
• MCP/A2A ਪ੍ਰੋਟੋਕੋਲ ਜਟਿਲ, ਮਲਟੀ-ਏਜੰਟ ਵਰਕਫਲੋਜ਼ ਦੀ ਆਰਕੈਸਟਰੇਸ਼ਨ ਲਈ ਲਾਜ਼ਮੀ ਹਨ।

ਜਿਵੇਂ-जਿਵੇਂ ਇਹ ਇਕੋਸਿਸਟਮ ਪੱਕਾ ਹੁੰਦਾ ਜਾਵੇਗਾ, ਅਸੀਂ ਉਮੀਦ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ LLMs ਵੱਲੋਂ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਦੀ ਨੁਮਾਇੰਦਗੀ, ਕਾਰਜਨਵੀਤੀ ਅਤੇ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਹੋਰ ਨਵੀਨਤਾ ਆਵੇਗੀ, ਜਿਸ ਨਾਲ ਬੁੱਧੀਮਾਨ ਆਟੋਮੇਸ਼ਨ ਅਤੇ ਸਹਿਯੋਗ ਲਈ ਨਵੀਆਂ ਸੰਭਾਵਨਾਵਾਂ ਖੁਲਣਗੀਆਂ।