एजेंट हार्नेस एक भाषा मॉडल के चारों ओर का सॉफ्टवेयर इंफ्रास्ट्रक्चर है जो इसे क्रियाएं करने में सक्षम बनाता है।

हार्नेस निम्नलिखित के लिए जिम्मेदार है:

• मॉडल का संदर्भ (context) तैयार करना।
• LLM के साथ संचार करना।
• LLM को टूल्स प्रदान करना।
• अनुरोधित टूल कॉल को निष्पादित करना।
• टूल के परिणामों को मॉडल तक वापस पहुँचाना।
• बातचीत और सत्रों (sessions) का प्रबंधन करना।
• निष्पादन जीवनचक्र (execution lifecycle) को नियंत्रित करना।

LLM तर्क क्षमताएं प्रदान करता है।

हार्नेस वह वातावरण प्रदान करता है जिसमें उस तर्क को क्रियाओं में अनुवादित किया जा सकता है।

एक पारंपरिक चैटबॉट आमतौर पर इस पैटर्न का पालन करता है:

flowchart LR
    A["User"] --> B["Prompt"]
    B --> C["LLM"]
    C --> D["Response"]

एक AI कोडिंग एजेंट एक निष्पादन वातावरण जोड़ता है:

flowchart TD
    A["User"] --> B["Pi Agent"]
    B --> C["LLM"]
    C --> D{"Tool needed?"}
    D -->|Yes| E["Execute Tool"]
    E --> F["Return Result"]
    F --> C
    D -->|No| G["Final Response"]

उदाहरण:

चैटबॉट: "यहाँ पायथन कोड है जो खर्चों की गणना करता है।"

Pi: "मैंने पायथन फाइलें बनाईं, प्रोग्राम निष्पादित किया, परीक्षण चलाए, और एक त्रुटि ठीक की।"

महत्वपूर्ण अंतर एक वास्तविक वातावरण के साथ बातचीत करने की क्षमता है।

न्यूनतमवाद (Minimalism):

• कोर को अपेक्षाकृत छोटा रखें।
• अनावश्यक अमूर्तता (abstractions) से बचें।
• मौजूदा ऑपरेटिंग सिस्टम टूल्स पर निर्माण करें।

विस्तारणीयता (Extensibility):

• कस्टम टूल्स बनाएं।
• एक्सटेंशन बनाएं।
• पुन: प्रयोज्य स्किल्स का उपयोग करें।
• बाहरी सेवाओं को कनेक्ट करें।

मॉडल स्वतंत्रता:

• विभिन्न LLM प्रदाताओं का उपयोग करें।
• एक ही वातावरण के भीतर मॉडल स्विच करें।
• मॉडल व्यवहार की तुलना करें।

पारदर्शिता:

• मॉडल प्रतिक्रियाओं का निरीक्षण करें।
• टूल निष्पादन का निरीक्षण करें।
• संशोधनों की समीक्षा करें।
• सत्र इतिहास की जांच करें।

एक बुनियादी Pi सेटअप को इनकी आवश्यकता नहीं होती:

• एक वेक्टर डेटाबेस।
• एक अलग ऑर्केस्ट्रेशन सर्वर।
• कुबेरनेट्स (Kubernetes)।
• डॉकर (Docker)।
• एक जटिल मल्टी-एजेंट फ्रेमवर्क।
• एक कस्टम बैकएंड एप्लिकेशन।

एक बुनियादी डेमो के लिए, एक टर्मिनल, एक समर्थित LLM, और एक स्थानीय निर्देशिका पर्याप्त है।

flowchart TB
    USER["Developer"]

    subgraph PI["Pi Coding Agent"]
        UI["Terminal Interface"]
        CORE["Agent Runtime"]
        CONTEXT["Context Manager"]
        SESSION["Session Manager"]
        TOOLS["Tool Execution"]
        EXT["Extensions / Skills"]
        API["LLM API Abstraction"]
    end

    subgraph MODELS["LLM Providers"]
        OPENAI["OpenAI"]
        ANTHROPIC["Anthropic"]
        GOOGLE["Google"]
        LOCAL["Local Models"]
    end

    subgraph SYSTEM["Development Environment"]
        FILES["File System"]
        BASH["Shell"]
        GIT["Git"]
        TESTS["Tests"]
    end

    USER <--> UI
    UI <--> CORE

    CORE <--> CONTEXT
    CORE <--> SESSION
    CORE <--> TOOLS
    CORE <--> API

    EXT --> CORE

    API <--> OPENAI
    API <--> ANTHROPIC
    API <--> GOOGLE
    API <--> LOCAL

    TOOLS <--> FILES
    TOOLS <--> BASH
    TOOLS <--> GIT
    TOOLS <--> TESTS

यह एक वैचारिक आर्किटेक्चर है, जो हर आंतरिक निर्भरता के बजाय प्रमुख जिम्मेदारियों को दर्शाता है।

Pi को TypeScript पैकेजों के संग्रह के रूप में विकसित किया गया है।

flowchart TD
    USER["Developer"]
    TUI["pi-tui"]
    CODING["pi-coding-agent"]
    CORE["pi-agent-core"]
    AI["pi-ai"]
    LLM["LLM Providers"]

    USER <--> TUI
    TUI <--> CODING
    CODING <--> CORE
    CORE <--> AI
    AI <--> LLM

    CODING --> FS["Tools"]
    CODING --> SESSION["Sessions"]
    CODING --> EXT["Extensions"]

उसी एजेंट इंफ्रास्ट्रक्चर का उपयोग गैर-इंटरैक्टिव इंटरफेस के माध्यम से भी किया जा सकता है।

उदाहरण:

"एक पायथन एप्लिकेशन बनाएं जो खर्चों को ट्रैक करे।"

Pi इस अनुरोध को अपने टर्मिनल इंटरफेस के माध्यम से प्राप्त करता है।

LLM से संपर्क करने से पहले, Pi संदर्भ तैयार करता है।

इसमें शामिल हो सकते हैं:

• सिस्टम निर्देश।
• उपयोगकर्ता अनुरोध।
• सक्रिय बातचीत का इतिहास।
• उपलब्ध टूल्स।
• AGENTS.md से प्रोजेक्ट निर्देश।
• कौशल विवरण।
• प्रासंगिक फाइल सामग्री।
• मॉडल कॉन्फ़िगरेशन।

सक्रिय सत्र शाखा यह निर्धारित करती है कि कौन से ऐतिहासिक संदेश शामिल किए गए हैं।

Pi तैयार अनुरोध को चयनित LLM प्रदाता को भेजता है।

LLM निम्नलिखित उत्पन्न कर सकता है:

• प्राकृतिक भाषा पाठ।
• संरचित टूल कॉल।
• दोनों का संयोजन।

उदाहरण टूल अनुरोध:

टूल: write फाइल: expenses.py सामग्री: पायथन सोर्स कोड

LLM सीधे फाइल नहीं लिखता है।

यह अनुरोध करता है कि Pi ऑपरेशन को निष्पादित करे।

Pi अनुरोधित टूल कॉल प्राप्त करता है।

टूल निष्पादक क्रिया करता है।

उदाहरण:

• फाइल पढ़ना।
• फाइल लिखना।
• कोड संशोधित करना।
• शेल कमांड निष्पादित करना।

Pi फिर परिणाम कैप्चर करता है।

आउटपुट एजेंट रनटाइम को वापस कर दिया जाता है।

उदाहरण:

टूल: bash कमांड: python expenses.py

परिणाम: Traceback: NameError …

परिणाम LLM के लिए उपलब्ध संदर्भ का हिस्सा बन जाता है।

LLM निर्णय ले सकता है:

• दूसरा टूल कॉल करना।
• कोड संशोधित करना।
• अतिरिक्त परीक्षण चलाना।
• अंतिम उत्तर प्रदान करना।

Pi प्रक्रिया को दोहराता है जब तक कि अधिक निष्पादन की आवश्यकता होती है।

यह इंटरैक्शन एजेंटिक व्यवहार की नींव है।

तीन जिम्मेदारियों को अलग किया गया है:

1. LLM: तर्क उत्पन्न करता है और क्रियाओं का प्रस्ताव देता है।
2. एजेंट हार्नेस: निष्पादन का समन्वय करता है और संदर्भ का प्रबंधन करता है।
3. टूल्स: वातावरण में संचालन करते हैं।

यह आर्किटेक्चर कई अन्य AI एजेंट कार्यान्वयनों के लिए भी मौलिक है।

फाइल सामग्री पढ़ें।

उदाहरण प्रॉम्प्ट:

"app.py पढ़ें और इसकी संरचना समझाएं।"

फाइलें बनाएं या ओवरराइट करें।

उदाहरण प्रॉम्प्ट:

"एक पायथन प्रोग्राम बनाएं जो Hello TechHive प्रिंट करे।"

मौजूदा फाइलों को संशोधित करें।

उदाहरण प्रॉम्प्ट:

"प्रोग्राम को उपयोगकर्ता नाम स्वीकार करने के लिए संशोधित करें।"

शेल कमांड निष्पादित करें।

उदाहरण प्रॉम्प्ट:

"प्रोग्राम चलाएं और परिणाम प्रदर्शित करें।"

flowchart TD
    A["User: Fix the bug"]
    B["LLM analyzes request"]
    C["read: Inspect code"]
    D["edit: Fix code"]
    E["bash: Run tests"]
    F{"Tests pass?"}
    G["Final response"]

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F -->|No| B
    F -->|Yes| G

संस्करण और कॉन्फ़िगरेशन के आधार पर अतिरिक्त अंतर्निहित टूल्स और एक्सटेंशन उपलब्ध हो सकते हैं।

संदर्भ वह जानकारी है जो मॉडल अनुरोध के लिए LLM को आपूर्ति की जाती है।

इसमें शामिल हो सकते हैं:

• वर्तमान उपयोगकर्ता अनुरोध।
• बातचीत का इतिहास।
• टूल परिणाम।
• सिस्टम निर्देश।
• प्रोजेक्ट निर्देश।
• कौशल विवरण।
• संदर्भित फाइल सामग्री।

Pi स्वचालित रूप से रिपॉजिटरी की हर फाइल को LLM संदर्भ में लोड नहीं करता है।

यह सत्र और कॉन्फ़िगर किए गए संसाधनों के आधार पर संदर्भ का चयन और संयोजन करता है।

AGENTS.md एक प्रोजेक्ट निर्देश फाइल है।

उदाहरण:

# Project Instructions

This project is for a coding-agent workshop.

Guidelines:
- Use Python.
- Prefer the standard library.
- Keep code simple.
- Write readable functions.
- Add tests for new features.
- Explain major changes.

ये निर्देश प्रोजेक्ट के भीतर एजेंट के व्यवहार को निर्देशित करने में मदद करते हैं।

Pi बातचीत सत्रों को बनाए रखता है।

सत्रों में शामिल हो सकते हैं:

• उपयोगकर्ता संदेश।
• सहायक संदेश।
• टूल कॉल।
• टूल परिणाम।
• मॉडल परिवर्तन।
• संदर्भ संकुचन (compaction) ईवेंट।

स्थायी सत्र JSONL फाइलों का उपयोग करते हैं।

Pi एक ट्री-आधारित बातचीत संरचना का समर्थन करता है।

flowchart TD
    A["Start Session"]
    B["Create Application"]
    C["Add Data Storage"]

    D["CSV Approach"]
    E["SQLite Approach"]

    F["Test CSV"]
    G["Test SQLite"]

    A --> B
    B --> C
    C --> D
    C --> E
    D --> F
    E --> G

शाखाएं पिछली बातचीत स्थितियों से वैकल्पिक दृष्टिकोणों की खोज की अनुमति देती हैं।

लंबी बातचीत मॉडल की संदर्भ विंडो से अधिक हो सकती है।

Pi भविष्य के मॉडल अनुरोधों में भेजी जाने वाली जानकारी की मात्रा को कम करने के लिए पुराने संदर्भ को संक्षेप में प्रस्तुत कर सकता है।

कमांड:

/compact

संकुचन संदर्भ के आकार को प्रबंधित करने में मदद करता है लेकिन पुराने संदेशों से कुछ विवरण खो सकता है।

मूल सत्र प्रविष्टियाँ संग्रहीत सत्र इतिहास में बनी रह सकती हैं।

flowchart TD
    USER["Developer"]
    PI["Pi Agent"]
    API["Unified Model Interface"]

    USER --> PI
    PI --> API

    API --> A["OpenAI"]
    API --> B["Anthropic"]
    API --> C["Google"]
    API --> D["Local Model"]

लाभ:

• लचीलापन।
• मॉडल तुलना।
• प्रदाता विकल्प।
• लागत अनुकूलन।
• प्रयोग।

मॉडल क्षमताएं और संगतता भिन्न हो सकती हैं।

प्रोजेक्ट-विशिष्ट निर्देश।

आवर्ती गतिविधियों के लिए पुन: प्रयोज्य प्रॉम्प्ट।

उदाहरण:

• कोड समीक्षा।
• दस्तावेज़ीकरण।
• परीक्षण पीढ़ी।
• रिफैक्टरिंग।

विशेष वर्कफ़्लो के लिए पुन: प्रयोज्य निर्देश और सहायक संसाधन।

उदाहरण:

• पायथन परीक्षण वर्कफ़्लो।
• परिनियोजन (deployment) वर्कफ़्लो।
• दस्तावेज़ीकरण पीढ़ी।
• API विकास।

TypeScript-आधारित अनुकूलन।

एक्सटेंशन कर सकते हैं:

• कस्टम टूल्स परिभाषित करना।
• कमांड पंजीकृत करना।
• जीवनचक्र ईवेंट पर प्रतिक्रिया करना।
• बाहरी सेवाओं को एकीकृत करना।
• इंटरैक्टिव व्यवहार को अनुकूलित करना।

MCP का अर्थ है Model Context Protocol।

यह एप्लिकेशन के लिए बाहरी टूल्स और संसाधनों तक पहुँचने का एक मानकीकृत तरीका प्रदान करता है।

आधुनिक Pi संस्करण अंतर्निहित MCP समर्थन प्रदान करते हैं।

उदाहरण एकीकरण:

• GitHub।
• डेटाबेस।
• आंतरिक एप्लिकेशन।
• रिमोट सेवाएं।

टर्मिनल इंटरफेस लॉन्च करें।

pi

एक प्रॉम्प्ट निष्पादित करें और उसकी प्रतिक्रिया प्रिंट करें।

pi -p "Explain Python decorators"

संरचित एजेंट ईवेंट स्ट्रीम करें।

pi --mode json -p "Explain this project"

मानक इनपुट और आउटपुट के माध्यम से JSONL संदेशों का उपयोग करके Pi को नियंत्रित करें।

TypeScript एप्लिकेशन में Pi एजेंट क्षमताओं को एम्बेड करें।

flowchart TD
    CORE["Pi Agent Runtime"]

    CORE --> A["Interactive TUI"]
    CORE --> B["Print / JSON"]
    CORE --> C["RPC"]
    CORE --> D["TypeScript SDK"]

    A --> E["Developer"]
    B --> F["Automation Scripts"]
    C --> G["External Application"]
    D --> H["Custom Agent Application"]

macOS / Linux:

curl -fsSL https://pi.dev/install.sh | sh

Windows PowerShell:

irm https://pi.dev/install.ps1 | iex

npm का उपयोग करके विकल्प:

npm install -g --ignore-scripts @earendil-works/pi-coding-agent

npm इंस्टॉलेशन के लिए Node.js 22.19 या नया संस्करण आवश्यक है।

Pi के अंदर:

/login

एक समर्थित प्रदाता चुनें और प्रमाणित करें।

फिर:

/model

वह मॉडल चुनें जिसका आप उपयोग करना चाहते हैं।

प्रॉम्प्ट:

Inspect the current directory.

Explain what files are present.

Do not modify anything.

अवधारणा: फाइल-सिस्टम अन्वेषण और पढ़ने के संचालन।

प्रॉम्प्ट:

Create a simple Python expense tracker.

Requirements:
- Add an expense.
- List expenses.
- Calculate total expenses.
- Store expenses in a CSV file.
- Use only the Python standard library.

Keep the implementation simple.

अवधारणा: कोड पीढ़ी और फाइल निर्माण।

प्रॉम्प्ट:

Run the application.

Create three example expenses.

Verify that the total is calculated correctly.

अवधारणा: शेल निष्पादन और परिणाम अवलोकन।

प्रॉम्प्ट:

Create unit tests using Python unittest.

Test expense creation and total calculation.

Run the tests and fix any errors.

अवधारणा: स्वायत्त परीक्षण और पुनरावृत्त सुधार।

प्रॉम्प्ट:

Add a feature to group expenses by category.

Display the total for each category.

Update the tests and run them.

अवधारणा: कोड संशोधन और संदर्भ प्रतिधारण।

कमांड:

/session /tree /model

अवधारणा: सत्र इतिहास, शाखाकरण, और मॉडल स्विचिंग।

न्यूनतम, विस्तार योग्य कोडिंग-एजेंट हार्नेस।

ताकत:

• अनुकूलन।
• एकाधिक LLM प्रदाता।
• टूल निष्पादन।
• सत्र प्रबंधन।
• विस्तारणीयता।

विकास टूल्स और वर्कफ़्लो के एकीकृत सेट के साथ कोडिंग एजेंट।

कोडबेस, टर्मिनल कमांड और विकास वर्कफ़्लो के साथ काम करने के लिए डिज़ाइन किया गया कोडिंग एजेंट।

कस्टम LLM एप्लिकेशन और एजेंटिक वर्कफ़्लो विकसित करने के लिए फ्रेमवर्क।

Pi मुख्य रूप से एक उपयोग के लिए तैयार और विस्तार योग्य एजेंट हार्नेस है, न कि सामान्य-उद्देश्य वाला वर्कफ़्लो-ग्राफ फ्रेमवर्क।