ai-agents-for-beginners

மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பை ஆராயும்

Agent Framework

அறிமுகம்

இந்த பாடம் கொண்டிருக்கும் விஷயங்கள்:

கற்றல் இலக்குகள்

இந்த பாடத்தை முடித்த பிறகு, நீங்கள் எப்படி செய்வது என்று அறிந்திருப்பீர்கள்:

குறியீட்டு எடுத்துக்காட்டுகள்

Microsoft Agent Framework (MAF) குறியீட்டு எடுத்துக்காட்டுகள் இந்த கோப்பகத்தில் xx-python-agent-framework மற்றும் xx-dotnet-agent-framework கோப்புகளில் கிடைக்கின்றன.

மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பைப் புரிந்துகொள்வது

Framework Intro

Microsoft Agent Framework (MAF) என்பது AI ஏஜென்ட்களை உருவாக்குவதற்கான மைக்ரோசாஃப்டின் ஒருங்கிணைந்த கட்டமைப்பாகும். இது உற்பத்தி மற்றும் ஆராய்ச்சி சூழல்களில் காணப்படும் பல்வேறு ஏஜென்டு பயன்பாடுகளை தீர்க்க விருப்பத்தன்மையை வழங்குகிறது, அவரவற்றில்:

உற்பத்தியில் AI ஏஜெண்ட்களை வழங்க, MAF இல் கீழ்க்காணும் அம்சங்களும் உள்ளன:

Microsoft Agent Framework என்பது ஒருங்கிணைப்பாக்கத்தை விரும்புவதிலும் கவனம் செலுத்தியுள்ளது:

இப்போது இவ் அம்சங்கள் மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பின் சில முக்கியக் கருத்துக்களில் எவ்வாறு பொருந்துகின்றன என்பதை பார்ப்போம்.

மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பின் முக்கியக் கருத்துக்கள்

ஏஜெண்ட்கள்

Agent Framework

ஏஜெண்ட்களை உருவாக்குதல்

ஏஜெண்ட் உருவாக்கல் என்பது inference சேவை (LLM வழங்குனர்),
AI ஏஜெண்ட் பின்பற்ற வேண்டிய அறிவுரைகள் தொகுப்பு மற்றும் ஒதுக்கப்பட்ட name என்பதைக் குறியிடுவது:

agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent( instructions="You are good at recommending trips to customers based on their preferences.", name="TripRecommender" )

மேலே Azure OpenAI பயன்படுத்தப்படுகிறது ஆனால் ஏஜெண்ட்கள் பல்வேறு சேவைகளை பயன்படுத்தி உருவாக்கப்படலாம், உதாரணமாக Microsoft Foundry Agent Service:

AzureAIAgentClient(async_credential=credential).create_agent( name="HelperAgent", instructions="You are a helpful assistant." ) as agent

OpenAI Responses, ChatCompletion APIகள்

agent = OpenAIResponsesClient().create_agent( name="WeatherBot", instructions="You are a helpful weather assistant.", )

agent = OpenAIChatClient().create_agent( name="HelpfulAssistant", instructions="You are a helpful assistant.", )

அல்லது தொலைநிலையிலும் A2A நெறிமுறையைப் பயன்படுத்தி:

agent = A2AAgent( name=agent_card.name, description=agent_card.description, agent_card=agent_card, url="https://your-a2a-agent-host" )

ஏஜெண்ட்களை இயக்குதல்

ஏஜெண்ட்கள் .run அல்லது .run_stream முறைகளைப் பயன்படுத்தி செயற்படுத்தப்படுகின்றன, தேவையான பதிலின் வகையின் (நான்-ஸ்ட்ரீமிங் அல்லது ஸ்ட்ரீமிங்) அடிப்படையில்.

result = await agent.run("What are good places to visit in Amsterdam?")
print(result.text)

async for update in agent.run_stream("What are the good places to visit in Amsterdam?"):
    if update.text:
        print(update.text, end="", flush=True)

ஒவ்வொரு ஏஜெண்ட் இயக்கத்திலும் max_tokens ஆகும் பயன்படுத்தப்படும் அதிகபட்ச குறியீட்டு எண்ணிக்கை, ஏஜெண்ட் அழைக்கக்கூடிய tools மற்றும் ஏஜெண்ட் பயன்படுத்தும் model போன்ற விருப்பங்களை தனிப்பயனாக்க முடியும்.

இந்த வசதி பயனர்களின் பணியை நிறைவேற்ற குறிப்பிட்ட மாதிரிகள் அல்லது கருவிகள் தேவைப்படும் சூழல்களில் பயனுள்ளதாகும்.

கருவிகள்

ஏஜெண்ட் வரையறுக்கும் போது கருவிகள் வரையறுக்கப்படலாம்:

def get_attractions( location: Annotated[str, Field(description="The location to get the top tourist attractions for")], ) -> str: """Get the top tourist attractions for a given location.""" return f"The top attractions for {location} are." 


# நேரடியாக ஒரு ChatAgent உருவாக்கும்போது

agent = ChatAgent( chat_client=OpenAIChatClient(), instructions="You are a helpful assistant", tools=[get_attractions]

மேலும் ஏஜெண்ட் இயக்கும் போது:


result1 = await agent.run( "What's the best place to visit in Seattle?", tools=[get_attractions] # இவ்வழக்கத்திற்கு மட்டுமே வழங்கப்படும் கருவி )

ஏஜெண்ட் த்ரெட்ஸ்

ஏஜெண்ட் த்ரெட்ஸ் பல முறை உரையாடல்களை கையாள பயன்படுத்தப்படுகிறது. த்ரெட்கள் உருவாக்கப்படும் இரண்டு வழிகள்:

த்ரெட் உருவாக்க குறியீடு இதுவாகும்:

# புதிய ஒரு திரெட்டை உருவாக்கவும்.
thread = agent.get_new_thread() # அந்த திரெட்டுடன் முகவரியை இயக்கவும்.
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)

பின் த்ரெட்டை பின்பு பயன்படுத்த சேமிக்க அளவாக்கம் செய்யலாம்:

# புதிய திரெட்டை உருவாக்குக.
thread = agent.get_new_thread() 

# திரெட்டுடன் முகவரியை இயக்கு.

response = await agent.run("Hello, how are you?", thread=thread) 

# சேமிப்புக்காக திரெட்டை தொடர்முறைப்படுத்துக.

serialized_thread = await thread.serialize() 

# சேமிப்பிலிருந்து ஏற்றுமதி செய்த பிறகு திரெட்டை நிலையை தொடர்முறைமீடு செய்யவும்.

resumed_thread = await agent.deserialize_thread(serialized_thread)

ஏஜெண்ட் மிடில்வேர்

ஏஜெண்ட்கள் கருவிகளுடன் மற்றும் LLMகளுடன் தொடர்பு கொண்டு பயனரின் பணிகளை நிறைவேற்றுகின்றன. சில சூழல்களில், அந்த தொடர்புகளுக்கு இடையில் எதாவது செயல்படுத்தவோ அல்லது பதிவு செய்வதோ தேவையாக இருக்கலாம். அதை செய்வதில் ஏஜெண்ட் மிடில்வேர் பயன்படும்.

Function Middleware

இந்த மிடில்வேர் ஏஜெண்டுக்கும் அது அழைக்கும் செயல்/கருவிக்கும் இடையே ஒரு செயல்பாட்டை இடைவிடாமல் இயக்க அனுமதிக்கிறது. உதாரணமாக, ஒரு செயலை அழைக்கும் பொழுது பதிவு செய்ய விரும்பினால் இம்முறை உதவும்.

கீழே, next என்பது அடுத்த மிடில்வேர் அல்லது உண்மையான செயலை அழைக்கிறதா என்பதை வரையறுக்கிறது.

async def logging_function_middleware(
    context: FunctionInvocationContext,
    next: Callable[[FunctionInvocationContext], Awaitable[None]],
) -> None:
    """Function middleware that logs function execution."""
    # முன் செயலாக்கம்: செயல்பாடு நிறைவேற்றுவதற்கு முன் பதிவு செய்யவும்
    print(f"[Function] Calling {context.function.name}")

    # அடுத்து உள்ள மித்வாயப்பயன் அல்லது செயல்பாட்டிற்கு தொடரவும்
    await next(context)

    # பின்வட்டார செயலாக்கம்: செயல்பாடு நிறைவேற்றப்பட்ட பிறகு பதிவு செய்யவும்
    print(f"[Function] {context.function.name} completed")

Chat Middleware

இந்த மிடில்வேர் ஏஜெண்டுக்கும் LLMக்கு இடையேயான கோரிக்கைகளுக்கு இடையேயும் செயல்படுத்த அல்லது பதிவு செய்ய அனுமதிக்கிறது.

இதில் AI சேவைக்கு அனுப்பப்படும் messages போன்ற முக்கிய தகவல்கள் உள்ளன.

async def logging_chat_middleware(
    context: ChatContext,
    next: Callable[[ChatContext], Awaitable[None]],
) -> None:
    """Chat middleware that logs AI interactions."""
    # முன் செயலாக்கம்: AI அழைப்புக்கு முன்பே பதிவு செய்யவும்
    print(f"[Chat] Sending {len(context.messages)} messages to AI")

    # அடுத்த மிடில் வேர் அல்லது AI சேவைக்கு தொடரவும்
    await next(context)

    # பின் செயலாக்கம்: AI பதிலுக்குப் பிறகு பதிவு செய்யவும்
    print("[Chat] AI response received")

ஏஜெண்ட் நினைவகம்

Agentic Memory பாடத்தில் கூறியபடி, நினைவகம் என்பது ஏஜெண்ட் வெவ்வேறு சூழல்களில் செயல்பட உதவும் முக்கிய கூறு. MAF பல வகையான நினைவகங்களை வழங்குகிறது:

In-Memory Storage

இது செயலியின் ஓட்ட நேரத்தில் த்ரெட்களில் சேமிக்கப்படும் நினைவகம்.

# புதிய திரெட்டை உருவாக்கவும்.
thread = agent.get_new_thread() # திரெட்டுடன் முகவரியை இயக்கவும்.
response = await agent.run("Hello, I am here to help you book travel. Where would you like to go?", thread=thread)

Persistent Messages

பல அமர்வுகளுக்கு இடையே உரையாடல் வரலாறு சேமிக்கும் நினைவகம் இது. இது chat_message_store_factory பயன்படுத்தி வரையறுக்கப்படுகிறது:

from agent_framework import ChatMessageStore

# ஒரு தனிப்பட்ட செய்திகள் சேமிப்பகத்தை உருவாக்கவும்
def create_message_store():
    return ChatMessageStore()

agent = ChatAgent(
    chat_client=OpenAIChatClient(),
    instructions="You are a Travel assistant.",
    chat_message_store_factory=create_message_store
)

Dynamic Memory

ஏஜெண்ட்கள் ரன் செய்யப்படுவதற்கு முன் சூழலில் சேர்க்கப்படும் நினைவகம். mem0 போன்ற வெளிப்புற சேவைகளில் சேமிக்கப்படலாம்:

from agent_framework.mem0 import Mem0Provider

# மேம்பட்ட நினைவக செயல்பாடுகளுக்கு Mem0 பயன்படுத்தல்
memory_provider = Mem0Provider(
    api_key="your-mem0-api-key",
    user_id="user_123",
    application_id="my_app"
)

agent = ChatAgent(
    chat_client=OpenAIChatClient(),
    instructions="You are a helpful assistant with memory.",
    context_providers=memory_provider
)

ஏஜெண்ட் பார்வையிடக்கூடியமை

நம்பகமான மற்றும் பராமரிக்கத்தகுந்த ஏஜென்டு அமைப்புகளை உருவாக்க பார்வை முக்கியத்துவம் வாய்ந்தது. MAF OpenTelemetry உடன் இணைந்து கண்காணிப்பு மற்றும் மீட்டர்களை வழங்குகிறது.

from agent_framework.observability import get_tracer, get_meter

tracer = get_tracer()
meter = get_meter()
with tracer.start_as_current_span("my_custom_span"):
    # ஏதாவது செய்
    pass
counter = meter.create_counter("my_custom_counter")
counter.add(1, {"key": "value"})

வேலைசெய்தல்கள் (Workflows)

MAF வேலைசெய்தல்கள் வழங்குகிறது; இது ஒரு பணியை நிறைவேற்ற முன்பதிவிக்கப்பட்ட படிகள் ஆகும் மற்றும் AI ஏஜென்ட்கள் அந்த படிகளில் கூறுகளாக உள்ளன.

வேலைசெய்தல்கள் பல கூறுகளைக் கொண்டுள்ளன, அவை கட்டுப்பாடுகளை மேம்படுத்துகின்றன. வேலைச் செயல்முறைகள் பல-ஏஜெண்ட் ஒழுங்கமைப்பை மற்றும் செயல்முறை நிலைகள் சேமிப்பதையும் இது இயலுமைப்படுத்துகிறது.

வேலைசெய்தல்களின் முக்கிய கூறுகள்:

ஏட்ரகர்கள் (Executors)

ஏட்ரகர்கள் உள்ளீட்டு செய்திகளை பெறுகின்றனர், ஒதுக்கப்பட்ட பணியை நிறைவேற்றுகின்றனர், பின்னர் ஒரு வெளியீட்டு செய்தியைக் கொடுக்கின்றனர். இது வேலைசெய்தலை பெரிய பணியை நிறைவேற்ற முன்னேற்றுகிறது. ஏட்ரகர்கள் AI ஏஜென்ட் அல்லது தனிப்பயன் லாஜிக் ஆகியவையாக இருக்க முடியும்.

இருப்புகள் (Edges)

இருப்புகள் வேலைசெய்தலில் செய்திகளின் ஓட்டத்தை வரையறுக்க பயன்படுத்தப்படுகின்றன. அவை:

நேரடி இருப்புகள் - ஏட்ரகர்களுக்கு இடையில் எளிய ஒரே-க்கு-ஒரு இணைப்பு:

from agent_framework import WorkflowBuilder

builder = WorkflowBuilder()
builder.add_edge(source_executor, target_executor)
builder.set_start_executor(source_executor)
workflow = builder.build()

நிபந்தனை முடிவுகள் - குறிப்பிட்ட நிபந்தனை நிறைவேறியவுடன் செயல்படும். உதாரணமாக, ஹோட்டல் அறைகள் இல்லாதபோது, ஏட்ரகர் மற்ற விருப்புகளை பரிந்துரைக்கலாம்.

Switch-case இருப்புகள் - உள்ள நிபந்தனைகளுக்கு அமைய செய்திகளை வேறுவேறு ஏட்ரகர்களை நோக்கி வழிசெய்கின்றன. உதாரணமாக, பயணக் கஸ்டமர் நன்கு முன்னதாக அணுகும் அனுமதி இருப்பின், அவர்களின் பணிகள் மற்ற வேலைசெய்தலில் கையாளப்படும்.

Fan-out இருப்புகள் - ஒரு செய்தியைக் பல இலக்குகளுக்கு அனுப்புதல்.

Fan-in இருப்புகள் - பல ஏட்ரகர்களிடமிருந்து செய்திகளை சேகரித்து ஒரே இலக்குக்கு அனுப்புதல்.

நிகழ்வுகள் (Events)

வேலைசெய்தல்களில் உள்ள செயலாக்கத்திற்கு மேம்பட்ட பார்வையிடல் தர MAF செயல்பாட்டு நிகழ்வுகளை வழங்குகிறது, அவை:

முன்னேற்ற MAF மாதிரிகள்

மேலே கூறப்பட்ட பகுதியில் மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பின் முக்கியக் கருத்துக்கள் உள்ளன. நீங்கள் மேலும் சிக்கலான ஏஜெண்ட்களை உருவாக்கும் போது, இதில் சில முன்னேற்ற மாதிரிகள் உள்ளன:

குறியீட்டு எடுத்துக்காட்டுகள்

Microsoft Agent Framework குறியீட்டு எடுத்துக்காட்டுகள் இந்த கோப்பகத்தில் xx-python-agent-framework மற்றும் xx-dotnet-agent-framework கோப்புகளில் கிடைக்கின்றன.

Microsoft Agent Framework குறித்த மேலும் கேள்விகள் உள்ளதா?

மற்ற கற்றுக்கொள்ளுநர்களுடன் சந்திக்க, அலுவலக நேரங்களில் கலந்துகொள்ள, உங்கள் AI ஏஜெண்ட் தொடர்பான கேள்விகளுக்கு பதில்களை பெற Microsoft Foundry Discord ஆக இணைந்து கொள்ளுங்கள்.

குறிப்பு:
இந்த ஆவணம் AI மொழிபெயர்ப்பு சேவையான Co-op Translator பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. நாங்கள் துல்லியத்துக்காக முயற்சித்தபோதும், தானாகச் செய்த மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறுகள் இருக்கக்கூடும் என்பதை தயவு செய்து கவனத்தில் கொள்ளவும். முதன்மை ஆவணம் அதன் சொந்த மொழியிலேயே அதிகாரப்படுத்தப்பட்ட மூலமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்முறை மனித மொழிபெயர்ப்பை பரிந்துரைக்கிறோம். இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்தவொரு தவறான புரிதலும் அல்லது தவறான விளக்கங்களுக்கும் நாங்கள் பொறுப்பில் இல்லை என்பதை தெரிவித்துக் கொள்ளுகிறோம்.

This site is open source. Improve this page.