Beranda>Terkait pemrograman>Kode Sumber AI
Unduh

gpt-agen-multi-atom

Kerangka kerja multi-agen dinamis sederhana berdasarkan agen atom dan Instruktur. Menggunakan kekuatan Pydantic untuk validasi dan serialisasi data dan skema.

  • composer Buat Agen yang dibuat dari prompt sistem, dengan bahasa bersama dari Panggilan Fungsi atau mutasi GraphQL

  • router menggunakan LLM untuk memproses permintaan pengguna 'komposit' yang kompleks, dan secara otomatis mengarahkannya ke urutan terbaik dari agen Anda

    • router menulis ulang prompt pengguna, agar sesuai dengan setiap agen

  • hasilkan melalui OpenAI atau AWS Bedrock atau groq

  • catatan: !! framework is at an early stage !! - perubahan yang melanggar akan ditandai dengan peningkatan versi minor (mayor masih nol).

Perkenalan

Kerangka Agen berbasis LLM menggunakan pendekatan Pemrograman Berorientasi Agen untuk mengatur agen menggunakan bahasa bersama.

Bahasa agen dapat berbasis Panggilan Fungsi , atau berbasis GraphQL .

Kerangka kerja ini bersifat umum dan memungkinkan agen untuk didefinisikan berdasarkan nama, deskripsi, panggilan masukan yang diterima, dan panggilan keluaran yang diizinkan.

Para agen berkomunikasi secara tidak langsung menggunakan papan tulis. Bahasa ini terdiri dari panggilan (Fungsi atau mutasi GraphQL): setiap agen menentukan apa yang dipahaminya sebagai masukan, dan panggilan apa yang dapat dihasilkannya. Dengan cara ini, para agen dapat memahami keluaran satu sama lain.

Router mengambil prompt pengguna dan menghasilkan rencana eksekusi agen.

Rencana eksekusi menggunakan urutan terbaik dari agen yang paling sesuai, untuk menangani permintaan pengguna.

Router menulis ulang perintah pengguna agar sesuai dengan setiap agen, yang meningkatkan kualitas dan menghindari keluaran yang tidak diinginkan.

catatan: Secara opsional, router dapat dijalankan secara terpisah, memungkinkan umpan balik manusia dalam loop mengenai rencana eksekusi yang dihasilkan router. Dengan cara ini, pengguna dapat lebih banyak berkolaborasi dengan router, sebelum agen generatif benar-benar dijalankan.

  • hal ini memungkinkan pengguna untuk memiliki kontrol lebih besar atas keluaran, dan memiliki manfaat tambahan yaitu mengurangi waktu yang diperlukan untuk menghasilkan, karena pengguna memiliki interaksi perantara dengan router.

Terakhir, output dikembalikan dalam bentuk daftar panggilan (Fungsi atau GraphQL) yang diurutkan.

Untuk membaca lebih lanjut tentang pendekatan ini, Anda dapat melihat artikel Medium ini.

  • catatan: framework is at an early stage . Evaluator saat ini belum diterapkan.

Integrasi

Saat melakukan integrasi, bergantung pada jenis Definisi Agen yang digunakan, klien perlu:

  • Agen Pemanggil Fungsi: klien mengimplementasikan fungsi. Klien menjalankan fungsi sesuai dengan hasil (panggilan fungsi) yang dihasilkan oleh kerangka ini.
    • pendekatan ini kurang fleksibel namun bagus untuk kasus penggunaan sederhana di mana GraphQL mungkin terlalu rumit
  • Agen berbasis GraphQL: Klien mengeksekusi mutasi GraphQL pada dokumen GraphQL yang sebelumnya mereka kirimkan ke kerangka kerja.
    • pendekatan ini memberikan fleksibilitas paling besar:
      • masukannya adalah skema GraphQL dengan panggilan mutasi yang dibuat sebelumnya, keluarannya adalah sekumpulan panggilan mutasi
      • agen dapat mengkomunikasikan generasi (modifikasi data) dengan menghasilkan mutasi GraphQL yang cocok dengan skema yang diberikan

Contoh [Pendekatan Berbasis Panggilan Fungsi]

Pembangun dunia Sim Life

Ini adalah demo pembangun dunia 'Sim Life'. Ia menggunakan 3 agen (Makhluk Makhluk, Pencipta Vegetasi, Pencipta Hubungan) untuk memproses permintaan pengguna. Agen didefinisikan berdasarkan fungsinya. Outputnya berupa rangkaian Panggilan Fungsi yang dapat diimplementasikan oleh klien, untuk membangun dunia Sim Life.

Definisi [Pendekatan Berbasis Panggilan Fungsi]

Fungsi AddCreature: 

 function_add_creature = FunctionSpecSchema (
    agent_name = creature_agent_name ,
    function_name = "AddCreature" ,
    description = "Adds a new creature to the world (not vegetation)" ,
    parameters = [
        ParameterSpec ( name = "creature_name" , type = ParameterType . string ),
        ParameterSpec ( name = "allowed_terrain" , type = ParameterType . string , allowed_values = terrain_types ),
        ParameterSpec ( name = "age" , type = ParameterType . int ),
        ParameterSpec ( name = "icon_name" , type = ParameterType . string , allowed_values = creature_icons ),
    ]
)

Fungsi AddCreatureRelationship: 

 function_add_relationship = FunctionSpecSchema (
    agent_name = relationship_agent_name ,
    function_name = "AddCreatureRelationship" ,
    description = "Adds a new relationship between two creatures" ,
    parameters = [
        ParameterSpec (
            name = "from_name" , type = ParameterType . string
        ),
        ParameterSpec (
            name = "to_name" , type = ParameterType . string
        ),
        ParameterSpec (
            name = "relationship_name" ,
            type = ParameterType . string ,
            allowed_values = [ "eats" , "buys" , "feeds" , "sells" ],
        ),
    ],
)

Definisi Agen [Pendekatan Berbasis Panggilan Fungsi]

Agen Pencipta Makhluk didefinisikan secara deklaratif dalam hal:

  • deskripsinya (prompt yang sangat singkat)
  • skema masukannya (daftar definisi fungsi yang diterima)
  • skema keluarannya (daftar definisi fungsi keluaran)

Agen dapat berkolaborasi dan bertukar informasi secara tidak langsung, dengan menggunakan kembali definisi fungsi yang sama melalui papan tulis. 

 def build_creature_agent ():
    agent_definition = FunctionAgentDefinition (
        agent_name = "Creature Creator" ,
        description = "Creates new creatures given the user prompt. Ensures that ALL creatures mentioned by the user are created." ,
        accepted_functions = [ function_add_creature , function_add_relationship ],
        input_schema = FunctionAgentInputSchema ,
        initial_input = FunctionAgentInputSchema (
            functions_allowed_to_generate = [ function_add_creature ],
            previously_generated_functions = []
        ),
        output_schema = FunctionAgentOutputSchema ,
        topics = [ "creature" ]
    )

    return agent_definition

Catatan tentang agen Pencipta Makhluk:

  • agen ini hanya dapat menghasilkan panggilan fungsi "AddCreature".
  • agen juga menerima (memahami) panggilan "AddCreature" sebelumnya, sehingga mengetahui apa yang telah dibuat.
  • selain itu, agen ini memahami subset pemanggilan fungsi dari agen: di sini, agen memahami fungsi "AddRelationship" yang ditentukan oleh function_add_relationship . Lihat contoh kode sumber untuk lebih jelasnya.

Contoh [Pendekatan Berbasis GraphQL]

Pembangun dunia Sim Life

Ini adalah demo pembangun dunia 'Sim Life'. Ia menggunakan 3 agen (Makhluk Makhluk, Pencipta Vegetasi, Pencipta Hubungan) untuk memproses permintaan pengguna. Agen didefinisikan secara deklaratif dalam skema masukan GraphQL, dan mengizinkan mutasi yang dihasilkan. Outputnya berupa rangkaian mutasi GraphQL yang dapat dieksekusi oleh klien, untuk membangun dunia Sim Life.

Definisi [Pendekatan Berbasis GraphQL]

Skema GraphQL: 

 type Creature {
  id : ID !
  creature_name : String !
  allowed_terrain : TerrainType !
  age : Int !
  icon_name : IconType !
}

type Vegetation {
  id : ID !
  vegetation_name : String !
  icon_name : IconType !
  allowed_terrain : TerrainType !
}

type Relationship {
  id : ID !
  from_name : String !
  to_name : String !
  relationship_kind : RelationshipType !
}
...

Mutasi GraphQL yang kita inginkan agar dihasilkan oleh Agen, berbeda untuk setiap agen:

Agen Pencipta Makhluk: 

 type Mutation {
  addCreature ( input : CreatureInput ! ): Creature !
}

input CreatureInput {
  creature_name : String !
  allowed_terrain : TerrainType !
  age : Int !
  icon_name : IconType !
}

Agen Pencipta Vegetasi: 

 type Mutation {
  addVegetation ( input : VegetationInput ! ): Vegetation !
}

input VegetationInput {
  vegetation_name : String !
  icon_name : IconType !
  allowed_terrain : TerrainType !
}

Definisi Agen [Pendekatan Berbasis GraphQL]

Agen Pencipta Makhluk didefinisikan secara deklaratif dalam hal:

  • deskripsinya (prompt yang sangat singkat)
  • skema masukannya (daftar skema GraphQL yang diterima)
  • skema keluarannya (daftar panggilan mutasi GraphQL keluaran)

Agen pada dasarnya adalah komposisi skema masukan dan keluaran, bersama dengan prompt.

Agen berkolaborasi dan bertukar informasi secara tidak langsung melalui papan tulis, dengan menggunakan kembali skema GraphQL dan panggilan mutasi yang sama. 

 creatures_graphql = _read_schema ( "creature.graphql" )
creature_mutations_graphql = _read_schema ( "creature.mutations.graphql" )

def build_creature_agent ():
    agent_definition = GraphQLAgentDefinition (
        agent_name = "Creature Creator" ,
        description = "Creates new creatures given the user prompt. Ensures that ALL creatures mentioned by the user are created." ,
        accepted_graphql_schemas = [ creatures_graphql , creature_mutations_graphql ],
        input_schema = GraphQLAgentInputSchema ,
        initial_input = GraphQLAgentInputSchema (
            mutations_allowed_to_generate = [ creature_mutations_graphql ],
            previously_generated_mutations = []
        ),
        output_schema = GraphQLAgentOutputSchema ,
        topics = [ "creature" ]
    )

    return agent_definition

Catatan tentang agen ini:

  • agen ini hanya dapat menghasilkan mutasi yang ditentukan oleh creature_mutations_graphql dari file "creature.mutations.graphql".
  • agen juga menerima (memahami) panggilan mutasi sebelumnya, sehingga mengetahui apa yang telah dibuat ( creature_mutations_graphql ).
  • selain itu, agen ini memahami skema GraphQL bersama yang ditentukan oleh creatures_graphql dari file "creature.graphql".
    • Array file GraphQL ini juga dapat digunakan untuk memungkinkan Agen memahami keluaran mutasi oleh agen lain.
    • Lihat contoh kode sumber untuk lebih jelasnya.

Menggunakan Agen dalam loop obrolan

Agen dapat digunakan bersama untuk membentuk bot obrolan: 

 from gpt_multi_atomic_agents import functions_expert_service , config
from . import agents

def run_chat_loop ( given_user_prompt : str | None = None ) -> list :
    CHAT_AGENT_DESCRIPTION = "Handles users questions about an ecosystem game like Sim Life"

    agent_definitions = [
        build_creature_agent (), build_relationship_agent (), build_vegatation_agent ()  # for more capabilities, add more agents here
    ]

    _config = config . Config (
        ai_platform = config . AI_PLATFORM_Enum . bedrock_anthropic ,
        model = config . ANTHROPIC_MODEL ,
        max_tokens = config . ANTHROPIC_MAX_TOKENS ,
        is_debug = False
        )

    return functions_expert_service . run_chat_loop ( agent_definitions = agent_definitions , chat_agent_description = CHAT_AGENT_DESCRIPTION , _config = _config , given_user_prompt = given_user_prompt )

catatan: jika given_user_prompt tidak disetel, maka run_chat_loop() akan menunggu input pengguna dari keyboard

Lihat contoh kode sumber untuk lebih jelasnya.

Contoh Eksekusi [Pendekatan Berbasis Panggilan Fungsi]

MASUKAN PENGGUNA: 

 Add a sheep that eats grass

KELUARAN: 

 Generated 3 function calls
[Agent: Creature Creator] AddCreature( creature_name=sheep, icon_name=sheep-icon, land_type=prairie, age=1 )
[Agent: Plant Creator] AddPlant( plant_name=grass, icon_name=grass-icon, land_type=prairie )
[Agent: Relationship Creator] AddCreatureRelationship( from_name=sheep, to_name=grass, relationship_name=eats )

Karena framework ini memiliki router dinamis, framework ini dapat menangani perintah 'composite' yang lebih kompleks, seperti:

Tambahkan sapi yang makan rumput. Tambahkan manusia - sapi memberi makan manusia. Tambahkan dan alien yang memakan manusia. Manusia juga memakan sapi.

Router menentukan agen mana yang akan digunakan, urutan menjalankannya, dan prompt apa yang dikirim ke setiap agen.

Secara opsional, router dapat dieksekusi ulang dengan umpan balik pengguna mengenai rencana yang dibuat, sebelum benar-benar mengeksekusi agen.

Agen yang direkomendasikan kemudian dieksekusi secara berurutan, mengumpulkan hasilnya di papan tulis bersama.

Terakhir, kerangka kerja menggabungkan panggilan yang dihasilkan dan mengembalikannya ke klien.

Contoh dijalankan melalui agen berbasis Panggilan Fungsi:

Contoh Eksekusi [Pendekatan Berbasis GraphQL]

MASUKAN PENGGUNA: 

 Add a sheep that eats grass

KELUARAN: 

 ['mutation {n    addCreature(input: {n      creature_name: "sheep",n      allowed_terrain: GRASSLAND,n      age: 2,n      icon_name: SHEEPn    }) {n      creature_namen      allowed_terrainn      agen      icon_namen    }n  }']
['mutation {', '  addVegetation(input: {', '    vegetation_name: "Grass",', '    icon_name: GRASS,', '    allowed_terrain: LAND', '  }) {', '    vegetation_name', '    icon_name', '    allowed_terrain', '  }', '}']
['mutation {', '  addCreatureRelationship(input: {', '    from_name: "Sheep",', '    to_name: "Grass",', '    relationship_kind: EATS', '  }) {', '    id', '  }', '}']

Contoh dijalankan melalui agen berbasis GraphQL:

Pengaturan

  1. Instal Python 3.11 dan puisi

  2. Instal dependensi. 

 poetry install
  1. Siapkan kredensial Anda untuk platform AI pilihan Anda.

Untuk OpenAI:

  • Anda perlu mendapatkan kunci Open AI.
  • Tetapkan variabel lingkungan untuk Anda dengan kunci Open AI Anda: 
 export OPENAI_API_KEY="xxx"

Tambahkan itu ke skrip inisialisasi shell Anda ( ~/.zprofile atau serupa)

Muat di terminal saat ini: 

 source ~/.zprofile

Penggunaan

Skrip tes: 

 ./test.sh

Lihat contoh kode sumber untuk lebih jelasnya.

Memperluas
Informasi Tambahan
Aplikasi Terkait
Direkomendasikan untuk Anda
Informasi Terkait Semua