pydantic/montyएआई द्वारा लिखे गए कोड के लिए Rust में लिखा गया एक सुरक्षित Python सैंडबॉक्स।
प्रायोगिक - यह प्रोजेक्ट अभी भी विकास के अंतर्गत है, और अभी पूर्ण रूप से उपयोग के लिए तैयार नहीं है।
AI द्वारा उपयोग के लिए Rust में लिखा गया एक न्यूनतम, सुरक्षित Python इंटरप्रेटर।
Monty, LLM द्वारा उत्पन्न कोड चलाने के लिए पूर्ण कंटेनर-आधारित सैंडबॉक्स का उपयोग करने की लागत, विलंबता, जटिलता और सामान्य झंझट से बचता है।
इसके बजाय, यह आपको अपने एजेंट में एम्बेड किए गए LLM द्वारा लिखे गए Python कोड को सुरक्षित रूप से चलाने देता है, जिसमें स्टार्टअप समय सैकड़ों मिलीसेकंड नहीं बल्कि एकल अंकों के माइक्रोसेकंड में मापा जाता है।
Monty क्या कर सकता है:
sys, os, typing, asyncio, re, datetime, json, dataclasses (जल्द ही)Monty क्या नहीं कर सकता:
संक्षेप में, Monty अत्यंत सीमित है और एक उपयोग के मामले के लिए डिज़ाइन किया गया है:
एजेंटों द्वारा लिखे गए कोड को चलाने के लिए।
आप ऐसा क्यों करना चाहेंगे इसकी प्रेरणा के लिए, देखें:
बहुत सरल शब्दों में, उपरोक्त सभी का विचार यह है कि LLMs तेज़ी से, सस्ते और अधिक विश्वसनीय रूप से काम कर सकते हैं यदि उन्हें पारंपरिक टूल कॉलिंग पर निर्भर रहने के बजाय Python (या Javascript) कोड लिखने के लिए कहा जाए। Monty इसे सैंडबॉक्स की जटिलता या सीधे होस्ट पर कोड चलाने के जोखिम के बिना संभव बनाता है।
नोट: Monty का उपयोग जल्द ही Pydantic AI में codemode लागू करने के लिए किया जाएगा
Monty को Python, JavaScript/TypeScript या Rust से कॉल किया जा सकता है।
स्थापित करने के लिए:```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