Podcasts पर वापस जाएंClaude
अपना पहला Managed Agent शिप करें
All right.
ठीक है।
Hello everyone.
नमस्ते सभी को।
It's great to see you all here today for our session on shipping your first manage agent.
आज यहाँ आप सबको देखकर बहुत अच्छा लगा, अपना पहला Managed Agent शिप करने के इस सत्र में आपका स्वागत है।
Let's go ahead and get started.
चलिए आगे बढ़ते हैं और शुरू करते हैं।
My name is Isabella He.
मेरा नाम Isabella He है।
I'm a member of technical staff at Anthropic on the Applied AI team.
मैं Anthropic में Applied AI team की Member of Technical Staff हूँ।
The Applied AI team at Anthropic sits at the intersection of products, research, and our customers, which means that I get to contribute internally to products at Anthropic like Claude code and our Claude harnesses, as well as work externally with our customers that are building on top of Claude and on top of our harnesses.
Anthropic की Applied AI team उत्पादों, शोध और हमारे ग्राहकों के बीच काम करती है, जिसका मतलब है कि मुझे Anthropic के उत्पादों जैसे Claude Code और हमारे Claude harnesses में आंतरिक योगदान देने का मौका मिलता है, साथ ही उन ग्राहकों के साथ बाहरी रूप से काम करने का भी जो Claude और हमारे harnesses पर निर्माण कर रहे हैं।
So, my goal today is to get you all hands-on with actually building on top of manage agents, understanding how the harness works under the hood, and getting you ready to actually ship your first incident response management.
तो, आज मेरा लक्ष्य है कि आप सब Managed Agents पर वास्तव में हाथों से काम करें, यह समझें कि यह harness अंदर से कैसे काम करता है, और आपको अपना पहला incident response management शिप करने के लिए तैयार करें।
So, the quick overview of today's agenda.
तो, आज के एजेंडे का एक संक्षिप्त अवलोकन।
We're going to cover first a quick refresher of Claude manage agents.
हम पहले Claude Managed Agents का एक त्वरित पुनरावलोकन करेंगे।
I want to talk you through a little bit about how this harness works under the hood and what makes it so special.
मैं आपको थोड़ा बताना चाहती हूँ कि यह harness अंदर से कैसे काम करता है और इसे इतना खास क्या बनाता है।
Our team put a lot of thought into the architectural design of Claude manage agents to make sure that it runs ready and reliably for production-ready agents.
हमारी team ने Claude Managed Agents के आर्किटेक्चरल डिज़ाइन में बहुत सोच-विचार किया ताकि यह सुनिश्चित किया जा सके कि यह production-ready agents के लिए तैयार और विश्वसनीय रूप से चले।
So, I want to talk you through a little bit of how that works so that then when we transition to the second portion here, which is the hands-on workshop, you'll actually understand what each of the primitives you're building actually mean for your agents under the hood.
तो, मैं आपको यह थोड़ा समझाना चाहती हूँ कि यह कैसे काम करता है, ताकि जब हम दूसरे भाग में जाएं, जो hands-on workshop है, तो आप वास्तव में समझ सकें कि आप जो primitives बना रहे हैं उनका आपके agents के लिए अंदर से क्या मतलब है।
So, for the majority of today's session, I want you all to actually have your laptops open, building alongside me, actually working inside of a repository, and getting you ready to actually spin up a working incident response agent.
तो, आज के सत्र के अधिकांश समय के लिए, मैं चाहती हूँ कि आप सब अपने laptops खोलें, मेरे साथ-साथ निर्माण करें, एक repository के अंदर काम करें, और एक working incident response agent तैयार करने के लिए खुद को तैयार करें।
Lastly, we'll talk a little bit about beyond the basics.
अंत में, हम basics से आगे के बारे में थोड़ा बात करेंगे।
Today's session is the first session of a couple of other ones that will build on top of this on Claude manage agents.
आज का सत्र कुछ अन्य सत्रों की श्रृंखला का पहला सत्र है जो Claude Managed Agents पर इसी के ऊपर बनेंगे।
Specifically, right after this one, I think there's another session on dreaming, which is one of my favorite new features with Claude manage agents for self-improving agents and memory built into the harness.
खासतौर पर, इस सत्र के ठीक बाद, मुझे लगता है कि dreaming पर एक और सत्र है, जो Claude Managed Agents में self-improving agents और memory के लिए मेरी पसंदीदा नई features में से एक है।
So, encourage everyone to dive in a little bit deeper into what else is in the box after we set you all up for success today with a quick introduction.
तो, सभी को प्रोत्साहित करती हूँ कि आज के इस quick introduction के बाद जो और चीजें इसमें हैं उनमें थोड़ा और गहराई से जाएं।
So, let's first touch a little bit about how we got here with Claude manage agents.
तो, पहले थोड़ा बात करते हैं कि हम Claude Managed Agents तक कैसे पहुँचे।
When we first released the very first Claude back in 2023, we released a messages API alongside access to Claude.
जब हमने 2023 में पहला Claude रिलीज़ किया, तो हमने Claude तक पहुँच के साथ Messages API भी रिलीज़ किया।
This provided raw model access to all Claude models.
इसने सभी Claude models तक raw model access प्रदान किया।
This became the very first way that people could programmatically build on top of Claude and essentially gave a way for people to access tokens in and tokens out via our Claude models.
यह पहला तरीका बन गया जिससे लोग Claude पर programmatically निर्माण कर सकते थे और हमारे Claude models के ज़रिए tokens in और tokens out तक पहुँचने का एक तरीका मिला।
This also meant that for everyone building on top of Claude models, they had to implement all the various primitives themselves.
इसका यह भी मतलब था कि Claude models पर निर्माण करने वाले सभी लोगों को सभी विभिन्न primitives खुद implement करने पड़ते थे।
Things like context management, the actual agent loop, compaction, etc.
जैसे context management, actual agent loop, compaction, इत्यादि।
All the primitives that come alongside making the agent work.
वे सभी primitives जो agent को काम करने के साथ आते हैं।
When models were less intelligent back in the early days of let's say 2023, some of these primitives were much simpler because agents could simply do less.
जब 2023 के शुरुआती दिनों में models कम intelligent थे, तो इनमें से कुछ primitives बहुत सरल थे क्योंकि agents बस कम काम कर सकते थे।
But, as we evolved into now with higher model intelligence and as agents are able to take on more complex tasks and actually take actions within environments and come to actually do entire tasks for humans, the primitives that come alongside context management and managing an agent's ability to execute API calls and tool calls becomes much more complex.
लेकिन, जैसे-जैसे हम अब उच्च model intelligence के साथ विकसित हुए और agents जटिल कार्य करने, environments में actions लेने और इंसानों के लिए पूरे tasks करने में सक्षम हुए, context management और agent की API calls तथा tool calls execute करने की क्षमता को manage करने के साथ आने वाले primitives बहुत जटिल हो गए।
So, that's when we moved to the agent SDK, which became a harness that allows you to programmatically call Claude code, one of our agents at Anthropic.
तो, तभी हम Agent SDK की ओर बढ़े, जो एक ऐसा harness बना जिससे आप Claude Code को programmatically call कर सकते हैं, जो Anthropic का एक agent है।
So, Claude code is something that an agent has access to a computer and takes actions within file system.
तो, Claude Code एक ऐसी चीज़ है जहाँ एक agent को computer तक access होता है और file system में actions लेता है।
So, the agent SDK became a way for you to make Claude much more powerful by leveraging the power of Claude code within a harness.
तो, Agent SDK एक तरीका बन गया जिससे आप Claude को बहुत अधिक शक्तिशाली बना सकते हैं, एक harness के भीतर Claude Code की शक्ति का लाभ उठाकर।
The main thing here though is that with the agent SDK, developers still had to manage hosting and scaling on their own and making sure that the agent SDK would be safe to run within their containers.
यहाँ मुख्य बात यह है कि Agent SDK के साथ, developers को अभी भी hosting और scaling खुद manage करनी पड़ती थी और यह सुनिश्चित करना पड़ता था कि Agent SDK उनके containers में सुरक्षित रूप से चलेगा।
That's only then evolved into Claude managed agents, which is the first harness to be able to handle scaling and production ready components for you by Anthropic, providing things like a purpose-built harness, sandboxing, observability, tool runtime, all within a managed infrastructure system.
यह तब Claude Managed Agents में विकसित हुआ, जो पहला harness है जो Anthropic द्वारा आपके लिए scaling और production-ready components को handle कर सकता है, जिसमें एक purpose-built harness, sandboxing, observability, tool runtime सब कुछ एक managed infrastructure system के भीतर शामिल है।
This means that developers can focus on task and agent configuration, custom tool logic, the things that actually matter for bringing domain expertise and customizability to your agents, where you're handing off the rest of all the primitives and core compute and primitives of essentially managing the basics of agent running to Anthropic.
इसका मतलब है कि developers task और agent configuration, custom tool logic पर ध्यान केंद्रित कर सकते हैं, वे चीजें जो आपके agents में domain expertise और customizability लाने के लिए वास्तव में मायने रखती हैं, जबकि बाकी सभी primitives और agent running के basics को Anthropic को सौंप देते हैं।
So, that brings me to managed agents as the fastest way to build production ready agents on Claude.
तो, यह मुझे Managed Agents तक लाता है जो Claude पर production-ready agents बनाने का सबसे तेज़ तरीका है।
We've seen people build 10 to 15 times faster to production with Claude managed agents by leveraging our purpose-built harness.
हमने देखा है कि लोग Claude Managed Agents का उपयोग करके हमारे purpose-built harness का लाभ उठाते हुए production तक 10 से 15 गुना तेज़ी से बनाते हैं।
Part of the reason why we built Claude managed agents is because is because harnesses should evolve alongside your agents.
हमने Claude Managed Agents बनाने का एक कारण यह है कि harnesses को आपके agents के साथ-साथ विकसित होना चाहिए।
For example, back when we were building ourselves on top of models like Sonnet 4.5, we noticed that Sonnet 4.5 emitted a particular behavior called context anxiety.
उदाहरण के लिए, जब हम खुद Sonnet 4.5 जैसे models पर निर्माण कर रहे थे, तो हमने देखा कि Sonnet 4.5 ने एक विशेष behavior दिखाया जिसे context anxiety कहते हैं।
This meant that with Sonnet 4.5, Claude started wrapping up tasks early even when it still had room to spare in its context window.
इसका मतलब था कि Sonnet 4.5 के साथ, Claude अपने context window में जगह होने के बावजूद tasks को जल्दी समाप्त कर देता था।
To manage that in our harness, we then added some mitigations to combat against this early stopping behavior.
इस early stopping behavior से लड़ने के लिए हमने अपने harness में कुछ mitigations जोड़े।
But, when Opus 4.5 then came out, we actually saw this behavior go away, making all that work we had done inside of the harness essentially obsolete because Claude had evolved beyond that behavior that we had built into the harness to manage.
लेकिन, जब Opus 4.5 आया, तो हमने देखा कि यह behavior चला गया, जिससे harness के अंदर हमारा किया गया सारा काम essentially अप्रचलित हो गया क्योंकि Claude उस behavior से आगे बढ़ चुका था जिसे manage करने के लिए हमने harness में बनाया था।
So, the takeaway there is that it's a lot of work to maintain harnesses and make sure that they actually evolve alongside your agents, which is why with Claude managed agents, we want to make it really easy for Claude and Anthropic to handle all the complexities that come with compaction, caching, things like context anxiety, all these various primitives that come with actually making agent production ready and getting the most out of Claude.
तो, वहाँ से सीख यह है कि harnesses को maintain करना और यह सुनिश्चित करना कि वे वास्तव में आपके agents के साथ-साथ विकसित हों, बहुत काम का है, इसीलिए Claude Managed Agents के साथ हम चाहते हैं कि Claude और Anthropic के लिए compaction, caching, context anxiety जैसी जटिलताओं को handle करना वास्तव में आसान हो, ये सभी विभिन्न primitives जो agent को production-ready बनाने और Claude से सर्वोत्तम परिणाम प्राप्त करने के साथ आते हैं।
So again, you can focus on the tasks, tools, and things that actually matter for building agents on Claude.
तो फिर से, आप tasks, tools, और उन चीज़ों पर ध्यान केंद्रित कर सकते हैं जो Claude पर agents बनाने के लिए वास्तव में मायने रखती हैं।
So three primary resources go into building on Claude managed agents.
तो Claude Managed Agents पर निर्माण करने के लिए तीन प्राथमिक संसाधन हैं।
First is the agent's endpoint, which is the persona and capabilities.
पहला है agent का endpoint, जो persona और capabilities है।
This is the core system prompt that powers your agent.
यह वह core system prompt है जो आपके agent को संचालित करता है।
Essentially here, you're defining the model, the MCP servers, the skills, the various components that your agent can actually leverage when it's able to run in that agent loop.
यहाँ essentially, आप model, MCP servers, skills, विभिन्न components को define कर रहे हैं जिनका आपका agent उपयोग कर सकता है जब वह उस agent loop में चलने में सक्षम होता है।
The next is the environments.
अगला है environments।
You can think of this as the hands of the agent, where the previous one is the brain of the agent where the agent is thinking through what to execute, and then it's using an environment to actually have a space and a container to actually take action on your behalf.
आप इसे agent के हाथ की तरह सोच सकते हैं, जहाँ पिछला वाला agent का दिमाग है जहाँ agent यह सोचता है कि क्या execute करना है, और फिर वह वास्तव में आपकी ओर से action लेने के लिए एक space और container पाने के लिए environment का उपयोग करता है।
Sessions are next the way to tie together agents and environments.
Sessions अगली हैं जो agents और environments को एक साथ जोड़ने का तरीका है।
A single session has a spun up on an agent instance within an environment.
एक single session एक environment के भीतर एक agent instance पर spin up होती है।
So you can connect the two together and actually stream events back to your user and start to take action on behalf of your humans as part of a Claude powered agent.
तो आप दोनों को एक साथ connect कर सकते हैं और वास्तव में events को अपने user तक stream कर सकते हैं और Claude-powered agent के हिस्से के रूप में इंसानों की ओर से actions लेना शुरू कर सकते हैं।
A key thing here, as I alluded to briefly before, Claude managed agent has the agent loop run server side.
यहाँ एक मुख्य बात, जैसा कि मैंने पहले संक्षेप में बताया था, Claude Managed Agents का agent loop server side चलता है।
This means that a lot of the complexities that come with managing hosting and scaling are abstracted away.
इसका मतलब है कि hosting और scaling manage करने की बहुत सी जटिलताएं abstract हो जाती हैं।
And when you close your laptop or you hit hard refresh on your agent that you're building on Claude managed agents, everything is maintained and you don't have to worry about durability, reliability, all these various aspects that usually come to bite you when you're trying to turn your agent from a prototype into production.
और जब आप अपना laptop बंद करते हैं या Claude Managed Agents पर बना रहे अपने agent पर hard refresh मारते हैं, तो सब कुछ maintain रहता है और आपको durability, reliability, इन सभी विभिन्न पहलुओं के बारे में चिंता नहीं करनी पड़ती जो आमतौर पर तब आती हैं जब आप अपने agent को prototype से production में लाने की कोशिश करते हैं।
And lastly here, before we dive into the hands-on portion, is I want to talk you through a key design decision that went into Claude managed agents.
और अंत में, hands-on भाग में जाने से पहले, मैं आपको Claude Managed Agents में गई एक प्रमुख design decision के बारे में बताना चाहती हूँ।
Previously, with a lot of agent harnesses, we saw the agent loop coupled tightly with tool execution.
पहले, बहुत सारे agent harnesses के साथ, हमने देखा कि agent loop tool execution के साथ tightly coupled था।
This design pattern made sense and still makes sense for some agents because you want to give the agent powerful abilities to actually take action within the environment.
यह design pattern समझ में आता था और कुछ agents के लिए अभी भी समझ में आता है क्योंकि आप agent को environment में वास्तव में action लेने की शक्तिशाली क्षमता देना चाहते हैं।
For instance, with Claude Code, we want the agent to be able to access various files on your computer, take action within a file system, and therefore it makes sense for the agent to have access to all those tools spun up on every container.
उदाहरण के लिए, Claude Code के साथ, हम चाहते हैं कि agent आपके computer पर विभिन्न files तक access कर सके, file system में action ले, और इसलिए यह समझ में आता है कि agent के पास हर container पर spin up सभी tools तक access हो।
But, we also realized there are some constraints for this, especially with some agents where you essentially want to be able to decouple the hands from the brains of the agents.
लेकिन, हमने यह भी महसूस किया कि इसके कुछ constraints हैं, खासकर कुछ agents के साथ जहाँ आप essentially agents के हाथ को दिमाग से decouple करना चाहते हैं।
For instance, credentials and uh credentials and security became a huge concern.
उदाहरण के लिए, credentials और उम credentials और security एक बड़ी चिंता बन गई।
With the ability to have the agent access your file system, you can actually add very distinct sandboxing by decoupling these two components, where the agent is no longer able to access the actual credentials without encryption by decoupling the hands from the sandbox of the agent.
agent को आपकी file system तक access देने की क्षमता के साथ, आप इन दो components को decouple करके वास्तव में बहुत अलग sandboxing जोड़ सकते हैं, जहाँ agent अब agent के sandbox से हाथ को decouple करके encryption के बिना actual credentials तक access नहीं कर सकता।
The other aspect here is actually you can see huge benefits by doing these decoupling on things like time to first token and latency.
दूसरा पहलू यह है कि आप इस decoupling को time to first token और latency जैसी चीज़ों पर करके वास्तव में बड़े लाभ देख सकते हैं।
Previously, with the agent loop into execution in the same box, you had to spin up containers for every single session that you're spinning up in the agent, which contributed to additional latency from a time to first time to first token perspective.
पहले, एक ही box में agent loop और execution के साथ, आपको agent में spin up कर रहे हर single session के लिए containers spin up करने पड़ते थे, जिसने time to first token के perspective से additional latency में योगदान किया।
But, with this now decoupled, our teams actually saw reductions in time to first token along the lines of over 90% reduction in TTFT for our P95 metrics on latency.
लेकिन, अब इसके decoupled होने के साथ, हमारी teams ने latency पर P95 metrics के लिए TTFT में 90% से अधिक की कमी देखी।
So, here you can start to see the power of this design decision coming through from the perspective of safety, reliability, latency, and everything else that you care about when it comes to building production-ready agents.
तो, यहाँ आप safety, reliability, latency और production-ready agents बनाते समय आपको जो कुछ भी परवाह है उसके perspective से इस design decision की शक्ति को देखना शुरू कर सकते हैं।
All right, so now it's time for the exciting part of today's session, which is where I want you all to open up your laptops and go to this URL here to actually clone a repository, and let's start to actually feel the magic of everything that I just talked through.
ठीक है, तो अब आज के सत्र के रोमांचक भाग का समय है, जहाँ मैं चाहती हूँ कि आप सब अपने laptops खोलें और एक repository clone करने के लिए यहाँ इस URL पर जाएं, और चलिए वास्तव में उन सभी चीज़ों के जादू को महसूस करना शुरू करते हैं जिनके बारे में मैंने अभी बात की।
So, I'm going to give everyone a second to just go over to that URL there and just spin up the repository that we have ready for you.
तो, मैं सभी को एक पल देने जा रही हूँ कि वहाँ उस URL पर जाएं और जो repository हमने आपके लिए तैयार की है उसे spin up करें।
All right, so here are some additional commands that I want you all to run to make sure this is all set up on your computers.
ठीक है, तो यहाँ कुछ additional commands हैं जो मैं चाहती हूँ कि आप सब चलाएं ताकि यह सुनिश्चित हो सके कि यह आपके computers पर सब set up है।
So, the first step many of you might have done already, but just take that repository, hit the URL, get clone it, and then I want you to CD into the specific repository for the session, which is ship your first manage agent.
तो, पहला step जो आप में से कई पहले ही कर चुके होंगे, लेकिन बस वह repository लें, URL पर जाएं, उसे clone करें, और फिर मैं चाहती हूँ कि आप सत्र के लिए specific repository में CD करें, जो है ship your first Managed Agent।
And then, if you're on Mac, you'll see those two commands on the side, the Python and the source.
और फिर, अगर आप Mac पर हैं, तो आपको side में वे दो commands दिखेंगे, Python और source।
Um, there's a command there for Windows as well.
उम, Windows के लिए भी वहाँ एक command है।
And you'll just do the rest there where you want to install the requirements, copy over the environment key into your .env file.
और आप बाकी काम करेंगे जहाँ आप requirements install करना चाहते हैं, environment key को अपनी .env file में copy करें।
Um, here you'll put in the Anthropic API key that hopefully all of you also received from the QR code for free credits earlier.
उम, यहाँ आप वह Anthropic API key डालेंगे जो उम्मीद है कि आप सभी को पहले free credits के लिए QR code से भी मिली थी।
And lastly, we'll just run the app.
और अंत में, हम बस app चलाएंगे।
All right, let's go ahead and dive in, but as I mentioned before, let me just show everyone where these instructions are.
ठीक है, चलिए आगे बढ़ते हैं और dive in करते हैं, लेकिन जैसा मैंने पहले बताया, मुझे बस सभी को दिखाना है कि ये instructions कहाँ हैं।
If you go into the repository in the link and then go to ship your first manage agents, you scroll down on the read me, you'll see all the setup instructions here.
अगर आप link में repository में जाते हैं और फिर ship your first Managed Agents में जाते हैं, तो आप readme पर scroll down करेंगे, आपको यहाँ सभी setup instructions दिखेंगी।
So, feel free to do this, um, as we go along or even in your own time later today and continue playing around with it, but as I mentioned before, everything will be also shown on the screen to follow along with.
तो, बेझिझक यह करें, उम, जैसे-जैसे हम आगे बढ़ें या बाद में आज अपने समय में और इसके साथ खेलते रहें, लेकिन जैसा मैंने पहले बताया, सब कुछ screen पर भी दिखाया जाएगा जिसे follow करना है।
So, do not worry if you did not have time to fully get it set up on your laptop.
तो, चिंता न करें अगर आपके पास इसे अपने laptop पर पूरी तरह set up करने का समय नहीं था।
Without further ado, let's go ahead and dive in.
बिना किसी और देरी के, चलिए आगे बढ़ते हैं और dive in करते हैं।
So, once you run streamlit run app.py, you should be able to see a URL that looks like this and a page that looks like this.
तो, एक बार जब आप streamlit run app.py चलाते हैं, तो आपको इस जैसा एक URL और इस जैसा एक page दिखना चाहिए।
What we're doing here is we're going to be simulating an agent, um, interaction here where we have an incident that's going to come up.
हम यहाँ क्या कर रहे हैं वह है एक agent interaction को simulate करना, उम, जहाँ हमारे पास एक incident आने वाला है।
A lot of you who might be software engineers in the room will be intimately familiar with the pain that comes alongside incident response.
आप में से बहुत से लोग जो कमरे में software engineers हो सकते हैं, incident response के साथ आने वाले दर्द से अच्छी तरह परिचित होंगे।
If you are software engineer, you might be woken up at, let's say, 3:00 a.m. in the morning, 2:00 a.m. in the morning when you're out around on on vacation as you're on call, and this is usually a very painful portion of a software engineer's life, uh, because when you're on call, it means that if a server goes down or a service goes down, you have to be immediately the one there to respond and tackle the incident.
अगर आप software engineer हैं, तो आपको शायद सुबह 3:00 बजे, 2:00 बजे जगाया जा सकता है जब आप on call होते हुए छुट्टी पर हों, और यह आमतौर पर एक software engineer की ज़िंदगी का बहुत दर्दनाक हिस्सा होता है, उह, क्योंकि जब आप on call होते हैं, इसका मतलब है कि अगर कोई server या service down हो जाती है, तो आपको तुरंत वहाँ पहुँचकर incident का जवाब देना और उसे संभालना होता है।
Usually for a human, this means diving into metrics and logs and deployments.
आमतौर पर एक इंसान के लिए, इसका मतलब है metrics, logs और deployments में गहराई से जाना।
You can actually investigate what's going on.
आप वास्तव में जाँच कर सकते हैं कि क्या हो रहा है।
And so, what we're going to do is we're going to now have an agent run on Claude manage agents to do all this for us.
और इसलिए, हम यह करने जा रहे हैं कि एक agent को Claude Managed Agents पर run करें जो यह सब हमारे लिए करे।
So, that when we get woken up by 3:00 a.m., we can hand it off to an agent, or maybe we don't even get woken up at all if Claude is able to do everything for us.
तो, जब हमें 3:00 बजे जगाया जाए, हम इसे एक agent को सौंप सकते हैं, या शायद हमें बिल्कुल भी नहीं जगाया जाए अगर Claude हमारे लिए सब कुछ करने में सक्षम है।
Okay.
ठीक है।
So, let's now go ahead and dive into the code here.
तो, चलिए अब आगे बढ़ते हैं और यहाँ code में dive करते हैं।
What we're going to open up here is we have the agent.py file on the left and the agent complete on the right.
हम यहाँ क्या खोलने जा रहे हैं वह यह है कि बाईं ओर agent.py file है और दाईं ओर agent complete है।
If you want to challenge yourself, you can of course try to implement everything yourself here or with Claude.
अगर आप खुद को challenge करना चाहते हैं, तो आप निश्चित रूप से यहाँ सब कुछ खुद या Claude के साथ implement करने की कोशिश कर सकते हैं।
Um but, what we're going to do just for simplicity's sake is just copy over various elements from the completed file onto the incomplete file one by one.
उम लेकिन, हम simplicity के लिए बस completed file से विभिन्न elements को एक-एक करके incomplete file पर copy करेंगे।
So, you can see how these primitives compose our agent one piece at a time.
तो, आप देख सकते हैं कि ये primitives हमारे agent को एक बार में एक piece कैसे compose करते हैं।
So, let's go ahead and start off with this very first part, which is the agent.
तो, चलिए आगे बढ़ते हैं और इस पहले भाग से शुरू करते हैं, जो agent है।
We mentioned before that the agent is the one that defines the persona and the capabilities of the agent here.
हमने पहले उल्लेख किया था कि agent वह है जो यहाँ हमारे agent की persona और capabilities को define करता है।
So, that's model, the system prompts, and the tools in our case for our agent here.
तो, हमारे agent के मामले में model, system prompts, और tools।
So, let me go ahead and copy over what we see there on the screen.
तो, चलिए मैं आगे बढ़ती हूँ और screen पर जो दिख रहा है उसे copy करती हूँ।
And you can see here that we're defining the SRE agent.
और आप यहाँ देख सकते हैं कि हम SRE agent को define कर रहे हैं।
We're going to use Claude Opus 4.7 here.
हम यहाँ Claude Opus 4.7 का उपयोग करने जा रहे हैं।
And I've preconfigured a system prompt and tools for the agent.
और मैंने agent के लिए एक system prompt और tools को पहले से configure किया है।