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

• மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பை புரிந்து கொள்வது: முக்கிய அம்சங்கள் மற்றும் மதிப்பு
• மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பின் முக்கியக் கருத்துக்களை ஆராய்வது
• முன்னேற்ற MAF மாதிரிகள்: பணியொற்றிகள், மிடில்வேர் மற்றும் நினைவகம்

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

• மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பை பயன்படுத்தி உற்பத்திக்கு தயாரான AI ஏஜென்ட்களை உருவாக்குவது
• உங்கள் ஏஜென்ட் பயன்பாடுகளுக்கு மைக்ரோசாஃப்ட் ஏஜென்ட் கட்டமைப்பின் முக்கிய அம்சங்களை பொருந்த வைப்பது
• வேலைசெய்தல், மிடில்வேர் மற்றும் பாறியக்கணிப்பு உட்பட முன்னேற்ற மாதிரிகளையை பயன்படுத்துவது

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

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

• இரண்டு முறை படிப்படியாக பணிசெய்ய வேண்டியவை உள்ள சூழல்களில் மொடிக்கு மோது ஏஜென்ட் ஒழுங்கமைப்பு
• ஏஜென்ட்கள் ஒரே நேரத்தில் பணிகளை நிறைவேற்ற வேண்டிய சூழல்களில் ஒரே நேர ஒழுங்கமைப்பு
• ஏஜென்ட்கள் ஒரே பணியில் ஒன்றாக ஒத்துழைக்கக்கூடிய சூழல்களில் குழு உரையாடல் ஒழுங்கமைப்பு
• துணைப் பணிகள் முடிந்தவுடன் ஏஜென்ட்கள் பணியினை ஒருவரிடமிருந்து மற்றவருக்கு ஒப்படைக்கும் சூழல்களில் கையளிப்பு ஒழுங்கமைப்பு
• மேலாளர் ஏஜெண்ட் பணியினை உருவாக்கி மாற்றங்கள் செய்யும் மற்றும் துணை ஏஜெண்ட்கள் ஒத்துழைக்க ஒழுங்கமைப்பை கையாளும் சூழல்களில் காந்த ஒழுங்கமைப்பு

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

• பார்வையிடக்கூடிய தன்மை OpenTelemetry யைப் பயன்படுத்தி, AI ஏஜென்ட் செயல்கள் அனைத்தும் அதாவது கருவி அழைப்பு, ஒழுங்கமைப்பு படிகள், காரணதிறன் பாய்கள் மற்றும் Microsoft Foundry டாஷ்போர்டுகள் மூலம் செயல்திறன் கண்காணிப்பு ஆகியவை.
• பாதுகாப்பு Microsoft Foundry இல் ஏஜெண்ட்களை தோற்றுவித்து, வேடிக்கைச் செயல்முறை அடிப்படையிலான அணுகல், தனிப்பட்ட தரவு கையாளுதல் மற்றும் உள்ளமைக்கப்பட்ட உள்ளடக்கம் பாதுகாப்பு போன்ற பாதுகாப்பு கட்டுப்பாடுகள்.
• நிலைத்தன்மை ஏஜென்ட் த்ரெட்கள் மற்றும் வேலைசெய்தல்கள் இடைநிறுத்தப்படும், மீண்டும் தொடங்கப்படும் மற்றும் பிழைகளிலிருந்து மீட்கப்படும் திறன் கொண்டதால், நீண்டகால இயங்கும் செயல்களை இயக்க முடியும்.
• கட்டுப்பாடு மனிதன் கட்டுப்பாட்டில் உள்ள வேலைசெய்தல்கள் ஆதரிக்கப்பட்டு, பணிகள் மனித ஒப்புதலை தேவைப்படுத்துகின்றன என்று குறிக்கப்படலாம்.

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

• மேகத் தொழில்நுட்பம் சாராது - ஏஜெண்ட்கள் கன்டெய்னர்களில், உள்ளகத்தில் மற்றும் பல்வேறு மெக் மேகங்களில் இயங்க முடியும்.
• வழங்குபவர் சாராது - Azure OpenAI மற்றும் OpenAI உட்பட, விரும்பிய SDK வழியாக ஏஜெண்ட்களை உருவாக்க முடியும்.
• திறந்த தரங்களுக்கு இணைவு - Agent-to-Agent (A2A) மற்றும் Model Context Protocol (MCP) போன்ற நெறிமுறைகளை பயன்படுத்தி மற்ற ஏஜெண்ட்கள் மற்றும் கருவிகள் கண்டுபிடிக்கப்பட்டு பயன்படுத்தப்படும்.
• பிளகின்கள் மற்றும் இணைப்பிகள் - Microsoft Fabric, SharePoint, Pinecone மற்றும் Qdrant போன்ற தரவு மற்றும் நினைவக சேவைகளுடன் இணைப்புகள்.

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

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

ஏஜெண்ட் உருவாக்கல் என்பது 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] # இவ்வழக்கத்திற்கு மட்டுமே வழங்கப்படும் கருவி )

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

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

• get_new_thread() பயன்படுத்தி, இது த்ரெட்டை நேரம் செலுத்தி சேமிக்க அனுமதிக்கும்
• ஏஜெண்ட் ஓடும் போது தானாக த்ரெட் உருவாகி, தற்போதைய ஓட்டத்தில் மட்டுமே செயல்படும்.

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

# புதிய ஒரு திரெட்டை உருவாக்கவும்.
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"})

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 செயல்பாட்டு நிகழ்வுகளை வழங்குகிறது, அவை:

• WorkflowStartedEvent - வேலைசெய்தல் செயல்பாடு ஆரம்பம்
• WorkflowOutputEvent - வேலைசெய்தல் வெளியீடு உண்டாக்கியது
• WorkflowErrorEvent - வேலைசெய்தல் பிழையை சந்தித்தது
• ExecutorInvokeEvent - ஏட்ரகர் செயல்பாட்டை தொடங்கியது
• ExecutorCompleteEvent - ஏட்ரகர் செயல்பாட்டை முடித்தது
• RequestInfoEvent - கோரிக்கை விடுத்தது

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

• மிடில்வேர் தொகுப்பு: பல மிடில்வேர் கையாளிகளை (பதிவு, அங்கீகாரம், அளவு கட்டுப்பாடு) செயல் மிடில்வேர் மற்றும் உரையாடல் மிடில்வேர் மூலம் சங்கிலியாக இணைத்து, ஏஜெண்ட் நடத்தையில் நுணுக்கமான கட்டுப்பாடு.
• வேலைசெய்தல் நிலை சேமிப்பு: வேலைசெய்தல் நிகழ்வுகள் மற்றும் அளவாக்கத்தைக் கொண்டு நீண்டநேர ஏஜெண்ட் செயல்முறைகளை சேமித்து மீண்டும் தொடங்குதல்.
• தொடர்புடைய கருவி தேர்வு: கருவி விளக்கங்களின் மீது RAG ஐ இணைத்து, MAF கருவி பதிவு மூலம் ஒவ்வொரு கேள்விக்கும் தேவையான கருவிகளை மட்டுமே வழங்குதல்.
• பல-ஏஜெண்ட் கையளிப்பு: வேலைசெய்தல் இருப்புகள் மற்றும் நிபந்தனை வழித்தடங்களை பயன்படுத்தி, சிறப்பு ஏஜெண்ட்களுக்கிடையே கையளிப்பை ஒழுங்கமைத்தல்.

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

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

---

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