లెటా ఎలా వాడుకోవాలి: స్టేట్ఫుల్ AI ఏజెంట్లను నిర్మించేందుకు ఒక ప్రాక్టికల్ గైడ్
మీ AI ఏజెంట్ సెషన్ల మధ్య కంటెక్ట్ గుర్తుంచుకోగలగాలి, టూల్స్ను నమ్మదగిన విధంగా నిర్వహించాలి, కాగితం స్క్రిప్ట్లు లేకుండా అభివృద్ధి చెందాలి అని భావించారా? అప్పుడు Letta మీకోసం రూపొందించబడింది. క్రింద Letta సెటప్ చేసుకోవడం, మీ మొదటి దీర్ఘకాలిక ఏజెంట్ను సృష్టించడం, మరియు నిజంగా పనిచేస్తున్న వర్క్ఫ్లోలను విడుదల చేసేందుకు ఒక దశల వారీ గైడ్ ఇచ్చాం.
గమనించదగ్గ విషయం: Letta ముందు MemGPT ప్రాజెక్టుతో సంబందించింది, ఇప్పుడు SDKలు, విజువల్ ఏజెంట్ డెవలప్మెంట్ ఎన్విరాన్మెంట్ (ADE) తో పూర్తి ప్లాట్ఫారంగా ఎదిగింది. మీరు త్వరగించుకోవడానికి క్విక్స్టార్ట్లు, అధికారిక డాక్యుమెంటేషన్, ఒక చిన్న పరిచయ వీడియో, మరియు ADE కోసం ప్రకటన పోస్ట్ను కనుగొనవచ్చు, ఇది లొ-కోడ్ UI కి అనుకూలం. Lettaలో స్టేట్ఫుల్ ఏజెంట్ల సూత్రపూర్వక నేపథ్యం కోసం ఏజెంట్ అవలోకనము చూడండి. MemGPT నుండి Letta కి రీ-నేమ్ మరియు ప్యాకేజ్ మార్పులపై ఆసక్తి ఉంటే, Python ప్యాకేజ్ నోట్స్ ఉపయోగకరమని, ఓపెన్ సోర్స్ రేపో ఆర్కిటెక్చర్ నేపథ్యం అందిస్తుంది.
ఈ గైడ్ ప్రాక్టికల్ & సొల్యూషన్-ఆరియెంటెడ్ శైలిలో రూపొందించబడింది: తక్కువ మాటలు, పేస్టు చేసుకోవడానికి ఇజీ స్టెప్స్, ప్రతి దశలో స్పష్టమైన నిర్ణయాలు.
Letta అంటే ఏమిటి (మరియు ఎందుకు ముఖ్యమారో)?
Letta ఒక ప్లాట్ఫారమ్, స్టేట్ఫుల్ AI ఏజెంట్లను నిర్మించడానికి—ఏజెంట్లు దీర్ఘకాలిక మెమరీని కలిగి ఉంటాయి, టూల్స్ను నిర్వహిస్తాయి, మరియు సంభాషణల మధ్య తమ స్థితిని నిలుపుకుంటాయి. ఒక స్టేట్లెస్ చాట్ వ్రాపర్ కాకుండా, Letta ఒక నిర్మాణాత్మక రన్టైమ్ అందిస్తుంది, అందులో ఏజెంట్లు:
- మెమరీ స్టోర్ని నిర్వహించి, సంబంధిత కంటెక్స్ట్ను ఆటోమేటెడ్గా తీసుకునే సామర్థ్యం కలిగి ఉంటాయి.
- స్కీమా-నియంత్రిత ఇన్పుట్స్తో టూల్స్ (ఫంక్షన్స్, APIs, వెబ్హుక్స్) కాల్ చేయగలవు.
- తమ కాన్ఫిగరేషన్ను నిలుపుతూ, వెర్షన్ చేయగలవు.
- క్లౌడ్లో లేదా లోకల్గా SDKలు (Python/TypeScript) లేదా లొ-కోడ్ విజువల్ ఎన్విరాన్మెంట్ (ADE) ద్వారా నడపవచ్చు.
మరింతగా, మీరు కస్టమర్ సపోర్ట్, రీసెర్చ్ అసిస్టెంట్, డేటా ఆప్స్, ప్రోడక్ట్ ఆప్స్ లేదా అంతర్గత ఆటోమెషన్ కోసం ఏజెంట్లు బిల్డ్ చేయవచ్చు, అవి ప్రాజెక్ట్ మధ్యలో మర్చిపోకపోవచ్చు.
త్వరిత నిర్ణయ వృక్షం: మీరు ఏ స్థాయిలో మొదలు పెట్టాలి?
- నేను కోడ్ ప్రిఫర్ చేసే డెవలపర్ → SDK క్విక్స్టార్ట్ (Python లేదా TypeScript) వాడండి.
- విజువల్ ప్రోటోటైపింగ్ చేసి, తరువాత కోడ్ ఎక్స్పోర్ట్ చేయాలనుకుంటున్నా → ADE మరియు ఏజెంట్ల అవలోకనం వాడండి.
- నిర్మాణం మరియు చరిత్రపై సమాచారం కావాలి → రేపో/README మరియు ప్యాకేజ్ నోట్స్ చదవండి.
- చిన్న దార్శనిక వీడియో కావాలి → పరిచయ వీడియో చూడండి.
సెటప్: జీరో నుండి మొదటి ఏజెంట్ (కోడ్ పథం)
ఇక్కడ SDK ఉపయోగించి వేగమైన మార్గం ఇస్తున్నాం (డాక్స్లో Python చూపబడింది; TypeScript దానితో సమానంగా ఉంటుంది).
- ఇన్స్టాల్ చేసి అథెంటికేట్ చేయండి
letta ప్యాకేజ్ డాక్స్ ప్రకారం ఇన్స్టాల్ చేయండి. మీ API కీ లేదా లోకల్ సర్వర్ క్రెడెన్షియల్స్ వాతావరణ వేరియబుల్స్ (ఉదా: LETTA_API_KEY) ద్వారా సెట్ చేయాలి.
- మీ ఏజెంట్ యొక్క సిస్టమ్ ప్రాంప్ట్ (పాత్ర), మెమరీ వ్యూహం, మరియు టూల్స్ జాబితా నిర్వచించండి. క్విక్స్టార్ట్ ఓ మినిమల్ వర్కింగ్ ఉదాహరణ చూపిస్తుంది.
- మెమరీ నిలుపుదల (పర్సిస్టెన్స్) జోడించండి
- పర్సిస్టెంట్ మెమరీ ఎనేబుల్ చేసి, ఏజెంట్ ఎలా మెమరీ స్టోర్ నుండి వ్రాయడం/పఠనం చేస్తుంది అనేది సెట్ చేయండి. ఏజెంట్ అవలోకనం Letta ఎలా స్థితిని నిలుపుకుంటుందో వివరిస్తుంది.
- టూల్స్ (ఫంక్షన్ కాలింగ్) జత చేయండి
- సખ్తమైన స్కీమాలతో ఫంక్షన్స్ నమోదు చేయండి. మొదట సులభమైన టూల్స్ వలన ప్రారంభించండి, ఉదా:
search_docs(query) లేదా create_ticket(data) మరియు అవసరం మేరకు విస్తరించండి.
- చిన్న టాస్క్స్ వాడి పరీక్షించండి (ఉదా: “ఈ కస్టమర్ థ్రెడ్ను సంగ్రహించి, రిజల్యూషన్ టికెట్ సృష్టించండి”). లాగులు మరియు మెమరీ ట్రేస్లు పరిశీలించి పనితీరు ధృవీకరించండి.
- డెవలప్మెంట్ కోసం లోకల్ రన్టైమ్ లేదా స్టేజింగ్/ప్రొడక్షన్ కోసం హోస్టెడ్ సెటప్ ఎన్నుకోండి. ఏజెంట్ కాన్ఫిగ్స్ మరియు టూల్స్ను వెర్షన్ చేయండి.
ఉదాహరణ: మినిమల్ ఏజెంట్ బ్లూప్రింట్ (సూడో-Python)
afrom letta import Client, Agent, Tool
client = Client(api_key=os.environ.
