AutoGen İle Çoklu Yapay Zekâ Ajan Sistemi Geliştirme

Merhaba,

Bir önceki AutoGen Nedir? Derinlemesine Teorik İnceleyelim… başlıklı içeriğimizde AutoGen’i teorik boyutta masaya yatırmış ve tam teferruatlı bir incelemede bulunmuştuk. Bu içeriğimizde ise edindiğimiz teorik zemin üzerine artık pratik bir inşada bulunacak ve AutoGen ile çoklu yapay zekâ ajan sistemlerinin (multi-agent systems) nasıl geliştirilebileceğinin derinliklerine temas ediyor olacağız. O halde vakit kaybetmeksizin buyurun başlayalım.

Temel Kurulum ve Yapılandırma
İlk olarak bir Console Application projesi oluşturulmalı ve bu projeye
dotnet add package AutoGen talimatıyla gerekli AutoGen kütüphanesi yüklenmelidir.

Ardından OpenRouter üzerinden bir api key edinilerek, Mistral: Ministral 8B AI modeli eşliğinde aşağıdaki değişkenler tanımlanıp, çalışmaya hali hazır bir altyapı oluşturulmalıdır.

string apiKey = "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";
string model = "mistral/ministral-8b";
string endpoint = "https://openrouter.ai/api/v1";

Evet, artık hazır olduğumuza göre başlayabiliriz.

Temel Seviyede Agent İnşası

AutoGen’de temel seviyede bir agent oluşturmak için manuel yapılandırma maliyetini göze alıp ConversableAgent tercih edilebilir, amma velakin hızlı bir yapılandırmayla en temelde bir agent ayağa kaldırmak için OpenAIChatAgent daha idealdir.

var assistantAgent = new OpenAIChatAgent(
      chatClient: new ChatClient(
          model: model,
          credential: new ApiKeyCredential(apiKey),
          options: new OpenAIClientOptions()
          {
              Endpoint = new Uri(endpoint)
          }),
      name: "assistant",
      systemMessage: "Sen kullanıcının bazı görevleri yapmasına yardımcı olan bir asistansın.")
      .RegisterMessageConnector()
      .RegisterPrintMessage();

Burada görüldüğü üzere AI modelle etkileşime girebilecek kullanıcıdan mesaj alabilen bir agent oluşturulmuştur. Hatırlarsanız eğer AutoGen’de her agent’ın görev ve yetenekleri yapacağı işin kapsamına göre özelleştirilebildiği için name ve systemMessage kısımlarında bunlar ayarlanmaktadır. Ayrıca tanımlamada yer alan RegisterMessageConnector metodu ile AI modelden gelecek mesajlar AutoGen’in anlayabileceği IMessage formatına dönüştürülmekte ve tam tersi işlem gerçekleştirilmektedir. Bir yandan da RegisterPrintMessage metodu ile de, bu agent’ın aldığı ve gönderdiği mesajlar console’a uygun bir formatta yazdırılmaktadır.

Tabi şimdi bu agent’la haberleşmeyi sağlayacak ve etkileşime girecek bir başka agent daha oluşturmamız gerekmektedir. Misal olarak aşağıdaki gibi UserProxyAgent aracılığıyla kullanıcıyı temsil eden bir agent oluşturulabilir.

var userProxyAgent = new UserProxyAgent(
    name: "user",
    humanInputMode: HumanInputMode.ALWAYS)
    .RegisterPrintMessage();

Evet, artık elimizde biri yardımcı olan biri de kullanıcıyı temsil eden iki adet agent mevcuttur. Artık bu agent’ların kendi aralarındaki haberleşmelerini başlatabiliriz. Bu haberleşme aşağıdaki gibi iki taraftan da başlayabilir;

• Kullanıcı agent’tan, assistant agent’a;

  await userProxyAgent.InitiateChatAsync(
      receiver: assistantAgent,
      message: Console.ReadLine(),
      maxRound: 10);
  

• Assistant agent’tan, kullanıcı agent’a;

  await assistantAgent.InitiateChatAsync(
      receiver: userProxyAgent,
      message: Console.ReadLine(),
      maxRound: 10);
  

Yukarıdaki yöntemleri incelersek iletişimin hangi agent’tan başlarsa başlasın InitiateChatAsync metodu aracılığıyla başlatılmakta olduğunu görüyoruz. Bir agent bu metot aracılığıyla receiver parametresine verilen agent’a mesajını gönderecek ve süreci başlatacaktır. Bu haberleşme sürecinde agent’lar arası yanıt döngüsü maxRound parametresiyle belirlenmekte ve böylece gereksiz API çağrıları ve sonsuz iletişimsel döngüler gibi durumlar engellenmektedir.

Bu yaptığımız geliştirmeyi derleyip çalıştırırsak eğer aşağıdaki ekran görüntüsünde olduğu gibi test edebilir ve agent’la sohbet edebiliriz.Bakın dikkat ederseniz artık sohbeti ayakta tutabilmek için herhangi bir döngüyle vs. iterasyonel çalışma yapmamıza gerek bulunmamaktadır. Çünkü oluşturduğumuz agent’lar sürekli bir şuur misali iletişim kurulabilir bir şekilde ayaktadırlar.

GenerateReplyAsync & SendAsync Metotları İle Haberleşme

Bir agent ile haberleşme sürecinde(ki bu haberleşme kullanıcı/agent arasında ya da agent/agent arasında olabilir) GenerateReplyAsync ve SendAsync metotlarını kullanarak farklı davranışlar sergilenebilmektedir. Şöyle ki;

• GenerateReplyAsync Metodu İle Haberleşme
  Bu metot, agent tarafından yalnızca bir yanıt üretilmesi için kullanılmaktadır. Genellikle konuşmanın kontrolü kullanıcıdaysa uygun olmakta ve daha çok test, debugging ya da kontrol senaryolarında tercih edilmektedir.

  var message = new TextMessage(Role.User, "Merhaba, sen kimsin?");
  IMessage reply = await chatAgent.GenerateReplyAsync([message]);
  

  Görüldüğü üzere bu metot girdi olarak bir mesaj dizisi almakta, haliyle bu diziye konuşma geçmişi verilerek bağlamla tutarlı bir cevap elde edilebilmektedir. Böylece çok adımlı, senkronize bir konuşma akışının neticesinde bir yanıt üretilmesi gerekiyorsa bu metot kullanılabilmektedir. Ancak şunu unutmamak gerekmektedir ki, bu metodun döndürdüğü yanıt ne GroupChat‘e iletilebilir, ne başka bir agent’a gönderilir ne de bir geri bildirim süreci tetikleyebilir. Yani anlayacağınız sohbetin akışı ilerlememektedir.

• SendAsync Metodu İle Haberleşme
  Bu metot ise mesajı agent’a göndermekte ve alınan cevabı varsa akış mantığına göre sonraki adımlara(başka agent’lara) yollamaktadır. Eğer ki söz konusu bir GroupChat‘se, bu metot aracılığıyla tüm süreç tetiklenir ve zincirleme agent iletişimi başlatılabilir.

  var message = new TextMessage(Role.User, "Merhaba, sen kimsin?");
  IMessage reply = await chatAgent.SendAsync(message);
  

Bu metotlar davranışsal olarak bahsedilen farklara sahip olsalar da manuel kontrol açısından da ciddi fark ortaya koymaktadırlar. Şöyle ki; GenerateReplyAsync metodunda agent’a gönderilen mesaj neticesinde yalnız yanıt alınabilmekte ve sistemin geri kalanına dair hiçbir şey gerçekleşmemektedir. Yani üretilecek bu cevap süreçte varsa başka agent’lar tarafından kontrol edilmemekte veyahut sistemle ilgili herhangi bir event tetiklenmemektedir. Bundan kaynaklı bu metodun kullanıldığı süreçlerde mesajın ne zaman, kime, nasıl gideceğine karar bizlerdedir. Haliyle oldukça sıkı bir manuel kontrol söz konusudur. SendAsync metodu ise sistemin içinde başka agent’larla olan bir akış söz konusuysa otomatik başlatacaktır ve gerektiği taktirde sistem event’lerinden tetikleme gerçekleştirecektir. Ee haliyle bu metotta süreç tarafımızca kontrol edilemediği için manuel kontrol paradigması oldukça zayıflık arz etmektedir.

Ve nihai olarak iki metot arasındaki teknik farklılıkları aşağıdaki tabloda özetleyerek devam edelim;

Streaming Chat

Agent’larla iletişim süreçlerinde yanıtı tamamen oluşana kadar beklemek yerine oluşturulan parçaları anlık olarak streaming(akış tabanlı) bir şekilde alabilmek mümkündür. Böylece uzun cevaplardan anlık tepki alınabilir ve bir yandan da typing gibi hisler oluşturularak kullanıcı deneyimleri iyileştirilebilir.

var message = new TextMessage(Role.User, "Tarihteki Memlükler devletiyle ilgili sence önemli olan hangi bilgi konuşmaya değer?");
await foreach (var reply in chatAgent.GenerateStreamingReplyAsync([message]))
{
    if (reply is TextMessageUpdate update)
        Console.WriteLine(update.Content);
}

Middlewares

AutoGen middleware yapısı sayesinde agent’lar arasında geçen mesajları ya da görev akışlarını kesebilmemizi ve böylece sürece dair analizler gerçekleştirebilmemizi, değişiklikler yapabilmemizi ya da yönlendirme olanağı sağlamaktadır. Esasında varlık nedeni Asp.NET Core’da ki bilinen middleware’lerle birebir aynı amaca hizmet etmektedir.

Aşağıda bir agent üzerinden basitçe middleware kullanımı örneklendirilmektedir;

var assistantAgent = new OpenAIChatAgent(
      chatClient: new ChatClient(
          model: model,
          credential: new ApiKeyCredential(apiKey),
          options: new OpenAIClientOptions()
          {
              Endpoint = new Uri(endpoint)
          }),
      name: "assistant",
      systemMessage: "Sen kullanıcının bazı görevleri yapmasına yardımcı olan bir asistansın.")
      .RegisterMessageConnector()
      //messages : O ana kadar geçen mesajlar - sohbet geçmişi
      //options : Yanıt üretim ayarları
      //agent : Middleware'in araya girdiği agent'ın kendisi
      .RegisterMiddleware(async (messages, options, agent, cancellationToken) =>
      {
          var lastMessage = messages.LastOrDefault();
          if (lastMessage is TextMessage textMessage && textMessage.Content.Contains("Merhaba"))
              return new TextMessage(Role.Assistant, "[middleware] Merhabe algılandı.");

          //Diğer durumlarda müdahale etme, varsayılan yanıtı üret!
          return await agent.GenerateReplyAsync(messages, options, cancellationToken);
      })
      .RegisterPrintMessage();

var reply = await assistantAgent.SendAsync("Merhaba");

Görüldüğü üzere RegisterMiddleware metodu aracılığıyla agent’a bir middleware tanımlanabilmekte ve üretilecek yanıt sürecinde rahatlıkla araya girilebilmektedir. Burada mühim olan ilgili metodun içerisine verilecek metod parametrelerinin ne işe yaradıklarının bilincinde olmaktır. Özellikle agent parametresinin o an middleware tarafından araya girilen agent olduğunun bilinmesinde fayda vardır.

Function Call

Kimi AI modellerinde, akıllıca işlemler yapabilmesi için sürece harici fonksiyonlar dahil edilebilmekte ve böylece üretilecek yanıtlar manipüle edilerek, AI modelinin yetkinliği arttırılabilmekte ve yetenekleri genişletilebilmektedir.

Peki nasıl function oluşturulur? diye sorduğunuzu duyar gibiyim… AutoGen’de function calling desteğini FunctionDefinition sınıfı üzerinden gerçekleştiriyoruz. Bunu manuel yapmaktansa AutoGen.SourceGenerator kütüphanesini kullanarak source generator’dan istifade edebilir ve otomatik olarak ilgili sınıfı oluşturtturabiliriz. Bunun için Function attribute’unu kullanacağız. Bu attribute ile işaretlenmiş olan metotların otomatik olarak function_calling formatına uygun olan FunctionDefinition dönüşümleri gerçekleştirilecek ve nesneleri elde edilecektir.

    public partial class Functions
    {
        /// <summary>
        /// Kullanıcı listesini getirir.
        /// </summary>
        /// <param name="userId">Eğer null değilse, yalnızca değeriyle eşleşen kullanıcıyı getirir.</param>
        [Function]
        async Task<string> GetUsersAsync(int? userId)
        {
            using HttpClient httpClient = new();
            var httpResponseMessage = await httpClient.GetAsync($"https://jsonplaceholder.typicode.com/users{(userId.HasValue ? $"/{userId.Value}" : "")}");
            var jsonResult = await httpResponseMessage.Content.ReadAsStringAsync();
            return jsonResult;
        }
    }

Yukarıdaki tanımda şunu demek istiyoruz : ‘Bu metodu LLM’e callable bir fonksiyon olarak sunmak istiyorum.’ Ee haliyle bunu reflection’la yapmaktansa source generator’ı devreye sokup gerekli FunctionDefinition nesnesini oluşturacak C# kodunu otomatik ürettiyoruz. Tabi bunun için source generator’ın fonksiyon tanımını üretirken gerekli olan fonksiyon dokümantasyonundan yararlanmasını sağlayabilmek için projede aşağıdaki gibi GenerateDocumentationFile özelliğini true olarak ayarlayıp XML belge desteğini etkinleştirmekte fayda vardır.

<Project Sdk="Microsoft.NET.Sdk">
	<PropertyGroup>
		.
		.
		.
		<GenerateDocumentationFile>true</GenerateDocumentationFile>
	</PropertyGroup>
	<ItemGroup>
		.
		.
		.
		<PackageReference Include="AutoGen.SourceGenerator" Version="0.2.3" />
	</ItemGroup>
</Project>

Ayrıca şunu da söylemekte fayda vardır ki; source generator’ın kod üretebilmesi için tıpkı yukarıdaki örnekte olduğu gibi public ve partial olan bir class gerekli ve Function attribute’u ile işaretlenmiş metotda public olmalı ve dönüş değeri olarak da Task<T> şeklinde tanımlanmalıdır. Ve unutulmamalıdır ki metot özet kısmındaki(summary) yazılanlar kritik arz etmektedir.

Evet, tüm çalışmalar anlatıldığı şekilde yapıldığı taktirde uygulama derlendiği vakit source generator devreye girecek ve gerekli function tanımı üretilecektir. Bu üretim neticesinde ilgili metodun LLM’e sunulması ve tetiklenebilmesi sürecinde merkezi rol oynayacak olan iki member oluşturulmuş olacaktır. Bunlar FunctionContract property’si ile birlikte Wrapper metodudur.

• FunctionContract
  İlgili fonksiyona dair adı, açıklaması, parametreleri vs. gibi bilgileri eşliğinde LLM’e bildirileceği sözleşmeyi yani kontrakt’ı ifade etmektedir. Yukarıdaki metoda karşı source generator aşağıdaki kontraktı üretecektir.

          public FunctionContract GetUsersAsyncFunctionContract
          {
              get => new FunctionContract
              {
                  Namespace = @"AutoGen_Example",
                  ClassName = @"Functions",
                  Name = @"GetUsersAsync",
                  Description = @"Kullanıcı listesini getirir.",
                  ReturnType = typeof(Task<string>),
                  Parameters = new global::AutoGen.Core.FunctionParameterContract[]
                  {
                      new FunctionParameterContract
                      {
                          Name = @"userId",
                          Description = @"Eğer null değilse, yalnızca değeriyle eşleşen kullanıcıyı getirir.",
                          ParameterType = typeof(int?),
                          IsRequired = true,
                      },
                  },
              };
          }
  

• Wrapper
  LLM’den gelen JSON formatındaki parametreleri doğru C# koduna dönüştüren metottur. Misal olarak; LLM bizlere
  {'userId': 3} döndürdüyse, bunu GetUsersAsyncWrapper(3) şeklinde yorumlayacaktır. Yine benzer mantıkla yukarıdaki metoda karşı source generator aşağıdaki Wrapper çalışmasını gerçekleştirmiştir.

          private class GetUsersAsyncSchema
          {
              [JsonPropertyName(@"userId")]
              public int? userId {get; set;}
          }
  

  Bakın, görüldüğü üzere önce ilgili metodun parametlerilerini temsil edecek bir schema sınıfı oluşturmuştur.

          public Task<string> GetUsersAsyncWrapper(string arguments)
          {
              var schema = JsonSerializer.Deserialize<GetUsersAsyncSchema>(
                  arguments, 
                  new JsonSerializerOptions
                  {
                      PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                  });
  
              return GetUsersAsync(schema.userId);
          }
  

  Ardından LLM’den gelen JSON formatındaki parametreleri bu schema sınıfı aracılığıyla deserialize edip kullanan GetUsersAsyncWrapper isimli wrapper metodunu oluşturmuştur.

Ne kadar kolay değil mi? AutoGen’in, biz geliştiricilerin deneyimini oldukça kolaylaştırması yetmiyormuş gibi bir de source generator ile bu tarz teferruatlı işlemlerin de sorumluluğunu bizlerden törpülemesi taktire şayan👏

Peki hoca! İyi güzel de bu fonksiyonu LLM’den nasıl çağıracağız? sorunuzu da duymuyor değilim. Bunun için aşağıdaki gibi ilgili agent’a RegisterMiddleware üzerinden FunctionCallMiddleware aracılığıyla hedef function(lar) kazandırılabilir ve örnekte olduğu gibi prompt’un mahiyetine göre AI modeli tarafından ilgili function(lar) tetiklenerek üretilecek yanıt şekillendirilip, sürece yeni davranış(lar) kazandırılabilir.

Functions functions = new();

var assistantAgent = new OpenAIChatAgent(
      chatClient: new ChatClient(
          model: model,
          credential: new ApiKeyCredential(apiKey),
          options: new OpenAIClientOptions()
          {
              Endpoint = new Uri(endpoint)
          }),
      name: "assistant",
      systemMessage: "Sen kullanıcının bazı görevleri yapmasına yardımcı olan bir asistansın.")
      .RegisterMessageConnector()
      .RegisterMiddleware(new FunctionCallMiddleware(
          functions: [functions.GetUsersAsyncFunctionContract],
          functionMap: new Dictionary<string, Func<string, Task<string>>>()
            {
                { nameof(Functions.GetUsersAsync), functions.GetUsersAsyncWrapper}
            }   
          ))
      .RegisterPrintMessage();

var result = await assistantAgent.GenerateReplyAsync([new TextMessage(Role.User, "bana tüm kullanıcıların bilgilerini getir")]);

Tabi GenerateReplyAsync metodu ile function calling tetikleneceği gibi SendAsync metoduyla da tetiklenecektir.

var result = await assistantAgent.SendAsync("bana tüm kullanıcıların bilgilerini getir");

Velhasıl, prompt neticesinde gelen cevap aşağıdaki görseldeki gibi olacaktır.Ayrıca function calling özelliğini, AI modelin çıktılarını parça parça elde ettiğimiz (streaming) senaryolardaki RegisterStreamingMiddleware üzerinden de aşağıdaki gibi devreye sokup benzer neticeyi elde edebiliriz.

      .RegisterStreamingMiddleware(new FunctionCallMiddleware(
          functions: [functions.GetUsersAsyncFunctionContract],
          functionMap: new Dictionary<string, Func<string, Task<string>>>()
          {
              { nameof(Functions.GetUsersAsync), functions.GetUsersAsyncWrapper}
          }))

Function calling özelliğini kullanabilmek için tercih edilen AI modelinin bu davranışı desteklemesi gerekmektedir. Bunun için içerik sürecinde bu başlıktaki testleri openai/gpt-4.1-nano AI modeliyle gerçekleştirmiş bulunuyorum.

ChatTool Sınıfı Nedir?
Bu sınıf, AutoGen içerisindeki function’ları temsil eden bir türdür. Bir başka deyişle, AI modelin function calling özelliğiyle çağırabileceği tüm function’lar ChatTool olarak tanımlanmaktadırlar.

Bir kontrakt üzerinden ChatTool nesnesine aşağıdaki gibi ToChatTool metodu aracılığıyla erişilebilmektedir.

var getUsersAsyncFunctionChatTool = functions.GetUsersAsyncFunctionContract.ToChatTool();

FunctionContract‘ı fonksiyonun yapısını JSON şeması misali ifade eden teknik dokümantasyon gibi düşünürsek, ChatTool ise bu şemayı LLM ile sohbet sırasında fiziksel olarak kullanılabilir bir nesne haline getiren araç olarak düşünebiliriz.

GetToolCalls Metodu Nedir?
Function calling’e dair bilinmesi gereken son şey ise GetToolCalls metodudur. Bu metot, IMessage türünden olan mesaj nesnelerinde mevcut olan ToolCallMessage‘ların listesini verecektir. Yani, AI modelinin yanıtı sürecinde yer alan tüm tool çağrılarını bizlere sunacaktır. Bunu daha net anlamak için aşağıdaki örnek üzerinden incelemede bulunmakta fayda vardır;

var result = await assistantAgent.GenerateReplyAsync([new TextMessage(Role.User, "bana 1,3 ve 5 id'li kullanıcıların bilgilerini getirir misin?")]);
var toolCalls = result.GetToolCalls();

Yukarıdaki isteği AI modeli şu şekilde yorumlayacaktır;

[
  { "name": "GetUsersAsync", "arguments": { "userId": 3 } },
  { "name": "GetUsersAsync", "arguments": { "userId": 5 } },
  { "name": "GetUsersAsync", "arguments": { "userId": 7 } }
]

Haliyle tüm bu tool’ları GetToolCalls metodunu çağırıp aşağıdaki görselde olduğu gibi programatik olarak elde edebiliriz;

Birden Fazla Agent’ı Kendi Aralarında Konuşturma

AutoGen’de birden fazla agent’ı kendi aralarında sıralı bir şekilde yahut belirlenen kurallara göre konuşturabilmekteyiz. Eğer ki sıralı bir şekilde konuşturulacaklarsa RoundRobinGroupChat, yok eğer belirlenen kurallara göre ya da agent’ların rol ve geçmişlerine göre konuşturulacaklarsa da GroupChat tercih edilmelidir.

Şimdi gelin GroupChat‘i belirli senaryo eşliğinde pratikte örneklendirelim;

GroupChat’i Kontrol Etmek İçin Graph Kullanımı
Bazen, GroupChat‘te çözmek istenen göreve bağlı olarak sıradaki agent’ın nasıl seçileceği konusunda daha fazla kontrol eklemek isteyebiliriz. Misal olarak, yukarıdaki örnekte admin’in doğrudan reviewer ile ve benzer şekilde coder’ın da runner ile iletişim kurması gerekmemektedir. Bunu aşağıdaki diyagramda gösterilen şekilde daha da idealize edebiliriz.Evet, GroupChat‘te belirli bir graph akışını takip edilebilir kılıp, agent’lara bir ön bilgi kazandırabilir ve konuşmayı daha verimli ve sağlam hale getirebiliriz. Bunun için yukarıdaki grafiği temsil edebilecek kodu aşağıda ele alabiliriz.

        public static async Task UseGraphToControlDynamicGroupChatAsync(string apiKey, string model, string endpoint)
        {
            var admin = await CreateAdminAgentAsync(apiKey, model, endpoint);
            var coder = await CreateCoderAgentAsync(apiKey, model, endpoint);
            var reviewer = await CreateReviewerAgentAsync(apiKey, model, endpoint);
            var runner = await CreateRunnerAgentAsync(apiKey, model, endpoint);

            var adminToCoderTransition = Transition.Create(admin, coder);

            var coderToReviewerTransition = Transition.Create(coder, reviewer);

            var reviewerToRunnerTransition = Transition.Create(
                from: reviewer,
                to: runner,
                canTransitionAsync: async (from, to, messages) =>
                {
                    var lastMessage = messages.LastOrDefault();
                    if (lastMessage is not TextMessage textMessage)
                        return false;

                    return textMessage.Content.Contains("Geçerli kod, runner kodu çalıştırabilir.");
                });

            var reviewerToCoderTransition = Transition.Create(
                from: reviewer,
                to: coder,
                canTransitionAsync: async (from, to, messages) =>
                {
                    var lastMessage = messages.LastOrDefault();
                    if (lastMessage is not TextMessage textMessage)
                        return false;

                    return textMessage.Content.Contains("Kod birden fazla kod bloğuna sahip. Lütfen tek bir kod bloğu gönder.");
                });

            var runnerToCoderTransition = Transition.Create(
                from: runner,
                to: coder,
                canTransitionAsync: async (from, to, messages) =>
                {
                    var lastMessage = messages.LastOrDefault();
                    if (lastMessage is not TextMessage textMessage)
                        return false;

                    return textMessage.Content.Contains("Geçersiz kod! Coder lütfen kodu yaz.");
                });

            var runnerToAdminTransition = Transition.Create(runner, admin);

            var groupChat = new GroupChat(
                admin: admin,
                workflow: new Graph(
                [
                    adminToCoderTransition,
                    coderToReviewerTransition,
                    reviewerToRunnerTransition,
                    reviewerToCoderTransition,
                    runnerToCoderTransition,
                    runnerToAdminTransition
                ]),
                members:
                [
                    admin,
                    coder,
                    runner,
                    reviewer,
                ]);

            admin.SendIntroduction("Gelen görevin çözüm sürecini takip edeceğim. İlk çözüldüğü zaman da süreci sonlandıracağım ve grupchat'i kapatacağım.", groupChat);
            coder.SendIntroduction("Gelen görevi çözmek için dotnet kodu yazacağım.", groupChat);
            reviewer.SendIntroduction("Coder tarafından üretilen dotnet kodunu kurallar doğrultusunda gözden geçireceğim. Onaylanmadığım zaman coder tekrardan kod yazdıracağım ve onaylayana kadar denetleyeceğim.", groupChat);
            runner.SendIntroduction("Reviewer incelemeye tamamladıktan sonra dotnet kodunu çalıştıracağım.", groupChat);


            var result = groupChat.SendAsync([new TextMessage(Role.User, "Bana fibonacci sayı diziminde 35. haneyi verir misin?", from: admin.Name)], maxRound: 15);
            await foreach (var message in result)
            {
                if (message.From == "runner")
                    Console.WriteLine(message.GetContent());
                await Task.Delay(1000);
            }
        }

Yukarıdaki çalışmaya göz atarsanız eğer Transition.Create() metodu ile agent’lar arasındaki geçişe dair hiyerarşi belirlenebilmekte ve dikkat ederseniz kimi durumlarda birden fazla kırılımın geçerli olabileceği çok ihtimalli süreçlerde yönlendirilebilecek şekilde tanımlanabilmektedirler.

Yukarıda verilen diyagramın koda yansıyışını okursak eğer; 8. satırdaki adminToCoderTransition transition ile admin’den coder’a, 10. satırdaki coderToReviewerTransition transition ile de coder’dan reviewer’a geçişi ifade etmektedir. Bu aşamada reviewer iki ihtimale sahiptir; ya kodu onaylayacak ve runner’a geçiş yapılacak ya da onaylamayacak ve coder’a tekrardan kod yazdırılacaktır. İşte bu durumda 12. satırdaki reviewerToRunnerTransition transition’ı kodun onaylandığı durumu temsil etmekte ve reviewer’dan runner’a geçişi ifade etmektedir. 24. satırdaki reviewerToCoderTransition transition’ı ise olası koşulsuzluklardan kaynaklı kodun tekrardan coder tarafından yazılması gerektiği durumu ifade etmektedir. Benzer mantıkla runner’da kodu çalıştırdığı taktirde ya başarılı olacak ve admin’e bildirecek ya da hata alacak ve coder’a geri dönecektir. Haliyle 36. satırdaki runnerToCoderTransition transition’ı ile koddaki olası hataya istinaden runner’dan coder’a geçiş ifade etmekteyken, 48. satırda ise runnerToAdminTransition transition’ı ile de sürecin nihai olarak başarıyla tamamlanacağını temsil etmektedir.

Graph, koşullu transition’ları/geçişleri desteklemektedir. Bir transition’ı koşullu hale getirmek için yukarıdaki örnekte olduğu gibi canTransitionAsync parametresine gerekli lambda fonksiyonu geçebilir ve transition’ın yapılıp yapılamayacağını belirten bir koşul çalışması gerçekleştirebilirsiniz.

Eğer ki tanımlanmış transtion’lardan birden fazla geçerli olan söz konusu olursa, bu taktirde GroupChat‘in yönetici agent’ı olan admin, konuşmanın bağlamına göre hangi duruma geçileceğine karar verecektir.

Ayrıca burada teknik olarak dikkat edilmesi gereken bir detay daha vardır ki; o da, graph’in kullanıldığı çalışmalarda admin’in 63. satırda olduğu gibi members’lara eklenmesi ve GroupChat‘i başlatacak olan SendAsync metoduna verilen TextMessage nesnesinde de ‘from’ olarak belirtilmesi gerekmektedir.

Nihai olarak;
Bu içeriğimizde AutoGen’i pratiksel olarak geniş açıdan deneyimlemiş ve temel agent yapılandırmalarından tutun, agent’ların aralarındaki haberleşme süreçlerindeki davranışlarına kadar detaylıca incelemiş bulunuyoruz. Bir yandan da agent’lar arasındaki iletişim anında kullanılabilecek streaming, middleware, function calling vs. gibi özelliklere temas etmiş ve güzel bir örnek senaryo üzerinden neyin ne olduğunu ve nerelerde ne şekilde kullanılabileceğini tecrübe etmiş bulunuyoruz. Özellikle function contract ve wrapper yapılanmalarını ve LLM ile herhangi bir function’ın nasıl call edilebileceğini detaylarıyla izah etmiş ve son olarak da tasarlanmış bir GroupChat’te Graph ile iletişim sürecini daha detaylı bir şekilde nasıl yapılandırabileceğimizi incelemiş bulunuyoruz.

Evet, bu içeriğimizde her ne kadar Semantic Kernel ile AutoGen’i birlikte kullanmaya değinmemiş olsak da sonraki yazılarımda bu iki teknolojiyi harmanlamayı ve ayrıca MCP (Model Context Protocol)‘yi de işin içine katarak süreci daha da yetenekli hale getirmeyi tasarlamıyor değilim 🙂 O halde takip kalın 😉

İlgilenenlerin faydalanması dileğiyle…
Sonraki yazılarımda görüşmek üzere…
İyi çalışmalar dilerim…

Not : Örnek çalışmaya aşağıdaki GitHub adresinden erişebilirsiniz.
https://github.com/gncyyldz/AutoGen_Example