---

प्रायोगिक - यह प्रोजेक्ट अभी भी विकास के अंतर्गत है, और अभी पूर्ण रूप से उपयोग के लिए तैयार नहीं है।

AI द्वारा उपयोग के लिए Rust में लिखा गया एक न्यूनतम, सुरक्षित Python इंटरप्रेटर।

Monty, LLM द्वारा उत्पन्न कोड चलाने के लिए पूर्ण कंटेनर-आधारित सैंडबॉक्स का उपयोग करने की लागत, विलंबता, जटिलता और सामान्य झंझट से बचता है।

इसके बजाय, यह आपको अपने एजेंट में एम्बेड किए गए LLM द्वारा लिखे गए Python कोड को सुरक्षित रूप से चलाने देता है, जिसमें स्टार्टअप समय सैकड़ों मिलीसेकंड नहीं बल्कि एकल अंकों के माइक्रोसेकंड में मापा जाता है।

Monty क्या कर सकता है:

• Python कोड का एक उचित उपसमुच्चय चलाएं - आपके एजेंट के लिए यह व्यक्त करने के लिए पर्याप्त है कि वह क्या करना चाहता है
• होस्ट वातावरण तक पहुंच को पूरी तरह से अवरुद्ध करें: फाइलसिस्टम, env वेरिएबल्स और नेटवर्क एक्सेस सभी बाहरी फ़ंक्शन कॉल के माध्यम से कार्यान्वित किए जाते हैं जिन्हें डेवलपर नियंत्रित कर सकता है
• होस्ट पर फ़ंक्शन कॉल करें - केवल वे फ़ंक्शन जिन तक आप इसे पहुंच देते हैं
• टाइपचेकिंग चलाएं - monty आधुनिक python टाइप हिंट्स का पूर्ण समर्थन करता है और टाइपचेकिंग चलाने के लिए एक ही बाइनरी में ty के साथ आता है
• बाहरी फ़ंक्शन कॉल पर बाइट्स में स्नैपशॉट किया जा सकता है, जिसका अर्थ है कि आप इंटरप्रेटर की स्थिति को फ़ाइल या डेटाबेस में संग्रहीत कर सकते हैं, और बाद में फिर से शुरू कर सकते हैं
• अत्यंत तेज़ स्टार्टअप (कोड से निष्पादन परिणाम तक <1μs), और CPython के समान रनटाइम प्रदर्शन (सामान्यतः 5x तेज़ से 5x धीमे के बीच)
• Rust, Python, या Javascript से कॉल किया जा सकता है - क्योंकि Monty की cpython पर कोई निर्भरता नहीं है, आप इसे कहीं भी उपयोग कर सकते हैं जहाँ आप Rust चला सकते हैं
• संसाधन उपयोग नियंत्रित करें - Monty मेमोरी उपयोग, स्टैक गहराई, और निष्पादन समय को ट्रैक कर सकता है और यदि यह पूर्व निर्धारित सीमाओं से अधिक हो जाता है तो निष्पादन रद्द कर सकता है
• stdout और stderr एकत्र करें और इसे कॉल करने वाले को लौटाएं
• होस्ट पर async या sync कोड को होस्ट पर async या sync कोड के माध्यम से चलाएं
• मानक लाइब्रेरी का एक छोटा उपसमुच्चय उपयोग करें: sys, os, typing, asyncio, re, datetime, json, dataclasses (जल्द ही)

Monty क्या नहीं कर सकता:

• मानक लाइब्रेरी के बाकी हिस्से का उपयोग करें
• थर्ड-पार्टी लाइब्रेरी (जैसे Pydantic) का उपयोग करें, बाहरी python लाइब्रेरी के लिए समर्थन एक लक्ष्य नहीं है
• क्लास परिभाषित करें (समर्थन जल्द ही आना चाहिए)
• मैच स्टेटमेंट का उपयोग करें (फिर से, समर्थन जल्द ही आना चाहिए)

---

संक्षेप में, Monty अत्यंत सीमित है और एक उपयोग के मामले के लिए डिज़ाइन किया गया है:

एजेंटों द्वारा लिखे गए कोड को चलाने के लिए।

आप ऐसा क्यों करना चाहेंगे इसकी प्रेरणा के लिए, देखें:

• Cloudflare से Codemode
• Anthropic से Programmatic Tool Calling
• Anthropic से Code Execution with MCP
• Hugging Face से Smol Agents

बहुत सरल शब्दों में, उपरोक्त सभी का विचार यह है कि LLMs तेज़ी से, सस्ते और अधिक विश्वसनीय रूप से काम कर सकते हैं यदि उन्हें पारंपरिक टूल कॉलिंग पर निर्भर रहने के बजाय Python (या Javascript) कोड लिखने के लिए कहा जाए। Monty इसे सैंडबॉक्स की जटिलता या सीधे होस्ट पर कोड चलाने के जोखिम के बिना संभव बनाता है।

नोट: Monty का उपयोग जल्द ही Pydantic AI में codemode लागू करने के लिए किया जाएगा

उपयोग

Monty को Python, JavaScript/TypeScript या Rust से कॉल किया जा सकता है।

Python

स्थापित करने के लिए:```bash uv add pydantic-monty

(या पुराने ज़माने के लिए `pip install pydantic-monty`)

`pydantic-monty` एक मेटापैकेज है जो `pydantic-monty-client` (मॉड्यूल `pydantic_monty`) को `pydantic-monty-runtime` (बाइनरी `monty` worker) के साथ जोड़ता है। यदि बाइनरी पहले से कहीं और से आती है तो केवल `pydantic-monty-client` इंस्टॉल करें।

Usage:```python
from typing import Any

import pydantic_monty

code = """
async def agent(prompt: str, messages: Messages):
    while True:
        print(f'messages so far: {messages}')
        output = await call_llm(prompt, messages)
        if isinstance(output, str):
            return output
        messages.extend(output)

await agent(prompt, [])
"""

type_definitions = """
from typing import Any

Messages = list[dict[str, Any]]

async def call_llm(prompt: str, messages: Messages) -> str | Messages:
    raise NotImplementedError()

prompt: str = ''
"""


Messages = list[dict[str, Any]]


async def call_llm(prompt: str, messages: Messages) -> str | Messages:
    if len(messages) < 2:
        return [{'role': 'system', 'content': 'example response'}]
    else:
        return f'example output, message count {len(messages)}'


async def main():
    async with pydantic_monty.AsyncMonty() as pool:
        async with pool.checkout(
            script_name='agent.py',
            type_check=True,
            type_check_stubs=type_definitions,
        ) as session:
            output = await session.feed_run(
                code,
                inputs={'prompt': 'testing'},
                external_lookup={'call_llm': call_llm},
            )
    print(output)
    #> example output, message count 2


if __name__ == '__main__':
    import asyncio

    asyncio.run(main())

निष्पादन monty वर्कर सबप्रोसेसों के एक पूल में होता है, इसलिए प्रतिकूल कोड द्वारा ट्रिगर की गई मेमोरी त्रुटि (स्टैक ओवरफ़्लो, एलोकेटर एबॉर्ट) भी आपकी प्रक्रिया को कभी क्रैश नहीं कर सकती — वर्कर मर जाता है, MontyCrashedError उठाता है, और उसे बदल दिया जाता है। एक पूर्णतः सिंक्रोनस API भी है:```python import pydantic_monty

with pydantic_monty.Monty() as pool: with pool.checkout() as session: # session state persists between feed_run calls session.feed_run('x = 21') print(session.feed_run('x * 2')) #> 42

### JavaScript / TypeScript

स्थापित करने के लिए:```bash
npm install @pydantic/monty

JS पैकेज उसी Rust worker pool पर एक नेटिव (napi) बाइंडिंग है जिसका Python पैकेज उपयोग करता है — बाइंडिंग और monty worker बाइनरी प्लेटफ़ॉर्म-विशिष्ट npm पैकेजों के माध्यम से वितरित की जाती हैं:```ts import { Monty } from '@pydantic/monty'

await using pool = await Monty.create() await using session = await pool.checkout()

// session state persists between feedRun calls await session.feedRun('x = 21') console.log(await session.feedRun('x * 2')) // 42