monty — AI द्वारा उपयोग के लिए Rust में लिखा गया एक न्यूनतम, सुरक्षित Python interpreter | Kitploit

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 (जल्द ही)

(या पुराने ज़माने के लिए `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())

ब्राउज़रों के लिए (या जहाँ कहीं सबप्रोसेस संभव न हों) वही पैकेज
`@pydantic/monty/wasm` सबपाथ के अंतर्गत एक इन-प्रोसेस WebAssembly बिल्ड प्रदान करता है
(कोई क्रैश आइसोलेशन नहीं: वहाँ एक सैंडबॉक्स क्रैश होस्ट क्रैश है)।

### Rust

Rust से अविश्वसनीय कोड चलाने के लिए, हम नीचे दिए गए इन-प्रोसेस API के बजाय
[`monty-pool`](https://crates.io/crates/monty-pool) क्रेट की अनुशंसा करते हैं।
`monty-pool` केवल `monty` वर्कर सबप्रोसेसों में कोड चलाता है, जो अतिरिक्त सुरक्षा प्रदान करता है:
प्रतिकूल कोड (स्टैक ओवरफ़्लो, एलोकेटर एबॉर्ट) से ट्रिगर हुआ क्रैश केवल वर्कर को मारता है —
पूल मौत का पता लगाकर वर्कर को बदल देता है — और एक पैरेंट-साइड वॉचडॉग उन वर्करों को मार सकता है
जो हार्ड टाइमआउट से अधिक समय लेते हैं। यह वही इंजन है जिस पर ऊपर दिए गए Python और JavaScript पैकेज बने हैं।
उपयोग के लिए [monty-pool README](https://github.com/pydantic/monty/tree/main/crates/monty-pool) देखें।

`monty` क्रेट स्वयं इन-प्रोसेस इंटरप्रेटर प्रदान करता है:```rust
use monty::MontyRun;
use monty_types::{CompileOptions, ResourceTracker, MontyObject, PrintWriter, ResourceLimits};

let code = r#"
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

fib(x)
"#;

let runner = MontyRun::new(code.to_owned(), "fib.py", vec!["x".to_owned()], CompileOptions::default()).unwrap();
let result = runner.run(vec![MontyObject::Int(10)], ResourceTracker::default(), PrintWriter::Stdout).unwrap();
assert_eq!(result, MontyObject::Int(55));

`MontyRun` और `RunProgress` का अपना कोई डंप प्रारूप नहीं है, लेकिन दोनों `serde::Serialize`/`Deserialize` लागू करते हैं, इसलिए एक होस्ट पार्स किए गए कोड या रोके गए रन को किसी भी ऐसे प्रारूप में serialize कर सकता है जिसका वह पहले से उपयोग करता है।

## वर्कर्स में मेमोरी सीमाएँ

किसी सत्र की `max_memory` वर्कर के आवंटक द्वारा मापी जाती है। इंटरप्रेटर सॉफ्ट सीमा पार करने के बाद एक सहज `MemoryError` रिपोर्ट करता है; एक उच्चतर हार्ड सीमा वर्कर को समाप्त कर देती है और उसे बदल देती है यदि कोई आवंटन चेकपॉइंट्स के बीच बहुत अधिक उछलता है।

सीमा पार होने पर यह होस्ट तक कैसे पहुँचता है, यह देखने के लिए [`limitations/resource_limits.md`](https://github.com/pydantic/monty/blob/main/limitations/resource_limits.md) देखें, और `monty-alloc` उस आवंटक के लिए देखें जिसके अंतर्गत सबप्रोसेस और WebAssembly दोनों वर्कर्स चलते हैं।

## PydanticAI एकीकरण

Monty [Pydantic AI](https://github.com/pydantic/pydantic-ai) में कोड-मोड को संचालित करेगा। अनुक्रमिक टूल कॉल करने के बजाय, LLM Python कोड लिखता है जो आपके टूल्स को फंक्शन के रूप में कॉल करता है और Monty इसे सुरक्षित रूप से निष्पादित करता है।```python test="skip"
import asyncio
import json

import logfire
from httpx import AsyncClient
from pydantic_ai import Agent, RunContext
from pydantic_ai.toolsets.code_mode import CodeModeToolset
from pydantic_ai.toolsets.function import FunctionToolset
from typing_extensions import TypedDict

logfire.configure()
logfire.instrument_pydantic_ai()


class LatLng(TypedDict):
    lat: float
    lng: float


weather_toolset: FunctionToolset[AsyncClient] = FunctionToolset()


@weather_toolset.tool
async def get_lat_lng(
    ctx: RunContext[AsyncClient], location_description: str
) -> LatLng:
    """Get the latitude and longitude of a location."""
    # NOTE: the response here will be random, and is not related to the location description.
    r = await ctx.deps.get(
        'https://demo-endpoints.pydantic.workers.dev/latlng',
        params={'location': location_description},
    )
    r.raise_for_status()
    return json.loads(r.content)


@weather_toolset.tool
async def get_temp(ctx: RunContext[AsyncClient], lat: float, lng: float) -> float:
    """Get the temp at a location."""
    # NOTE: the responses here will be random, and are not related to the lat and lng.
    r = await ctx.deps.get(
        'https://demo-endpoints.pydantic.workers.dev/number',
        params={'min': 10, 'max': 30},
    )
    r.raise_for_status()
    return float(r.text)


@weather_toolset.tool
async def get_weather_description(
    ctx: RunContext[AsyncClient], lat: float, lng: float
) -> str:
    """Get the weather description at a location."""
    # NOTE: the responses here will be random, and are not related to the lat and lng.
    r = await ctx.deps.get(
        'https://demo-endpoints.pydantic.workers.dev/weather',
        params={'lat': lat, 'lng': lng},
    )
    r.raise_for_status()
    return r.text


agent = Agent(
    'gateway/anthropic:claude-sonnet-4-5',
    # toolsets=[weather_toolset],
    toolsets=[CodeModeToolset(weather_toolset)],
    deps_type=AsyncClient,
)


async def main():
    async with AsyncClient() as client:
        await agent.run('Compare the weather of London, Paris, and Tokyo.', deps=client)


if __name__ == '__main__':
    asyncio.run(main())

तकनीक	भाषा पूर्णता	सुरक्षा	स्टार्ट विलंबता	FOSS	सेटअप जटिलता	फ़ाइल माउंटिंग	स्नैपशॉटिंग
Monty	आंशिक	सख्त	0.06ms	मुफ़्त / OSS	आसान	आसान	आसान
Docker	पूर्ण	अच्छी	195ms	मुफ़्त / OSS	मध्यम	आसान	मध्यम
Pyodide	पूर्ण	कमज़ोर	2800ms	मुफ़्त / OSS	मध्यम	आसान	कठिन
starlark-rust	बहुत सीमित	अच्छी	1.7ms	मुफ़्त / OSS	आसान	उपलब्ध नहीं?	असंभव?
WASI / Wasmer	आंशिक, लगभग पूर्ण	सख्त	66ms	मुफ़्त *	मध्यम	आसान	मध्यम
sandboxing service	पूर्ण	सख्त	1033ms	मुफ़्त नहीं	मध्यम	कठिन	मध्यम
YOLO Python	पूर्ण	मौजूद नहीं	0.1ms / 30ms	मुफ़्त / OSS	आसान	आसान / डरावना	कठिन

भाषा पूर्णता: पूर्ण CPython, शुद्ध Python बाहरी पैकेज माउंटिंग के माध्यम से काम करते हैं, C बाइंडिंग वाले बाहरी पैकेज काम नहीं करते
सुरक्षा: सिद्धांत रूप में WebAssembly को मजबूत सैंडबॉक्सिंग गारंटी प्रदान करनी चाहिए।
स्टार्ट विलंबता: wasmer python पैकेज को 3 साल से अपडेट नहीं किया गया है और मुझे Python से wasmer में Python को कॉल करने के दस्तावेज़ नहीं मिले, इसलिए मैंने इसे subprocess के माध्यम से कॉल किया। स्टार्ट विलंबता 66ms थी।
सेटअप जटिलता: wasmer डाउनलोड 100mb है, "python/python" पैकेज 50mb है।
FOSS: मैंने इसे "मुफ़्त *" चिह्नित किया है क्योंकि लागत शून्य है लेकिन सब कुछ ओपन सोर्स नहीं लगता। 2026-02-10 तक python/python wasmer पैकेज में कोई readme नहीं है, कोई लाइसेंस नहीं है, कोई सोर्स लिंक नहीं है और यह संकेत नहीं है कि इसे कैसे बनाया गया है; हाल ही में अपलोड किए गए संस्करणों का आकार "0B" दिखाता है जबकि डाउनलोड ~50MB है - Python बाइनरी के लिए बिल्ड प्रक्रिया स्पष्ट और पारदर्शी नहीं है। (अगर मैं यहाँ गलत हूँ, तो कृपया मुझे सही करने के लिए एक issue बनाएँ)
फ़ाइल माउंटिंग: समर्थित
स्नैपशॉटिंग: जर्नलिंग के माध्यम से समर्थित

monty

सबसे लोकप्रिय

उपयोग

Python

क्रमबद्धता

सामुदायिक बाइंडिंग्स

विकल्प

Monty

Docker

Pyodide

starlark-rust

WASI / Wasmer

sandboxing service

YOLO Python

Pydantic स्टैक का हिस्सा

monty

सबसे लोकप्रिय

Monty

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

उपयोग

Python

क्रमबद्धता

सामुदायिक बाइंडिंग्स

विकल्प

Monty

Docker

Pyodide

starlark-rust

WASI / Wasmer

sandboxing service

YOLO Python

Pydantic स्टैक का हिस्सा