Menyesuaikan template aplikasi

Di Mengembangkan aplikasi, kami menggunakan template bawaan (yaitu reasoning_engines.LangchainAgent) untuk mengembangkan aplikasi. Di bagian ini, kita akan membahas langkah-langkah untuk menyesuaikan template aplikasi Anda sendiri. Hal ini mungkin berguna jika Anda memiliki kebutuhan yang melebihi apa yang disediakan template bawaan.

Template aplikasi di Reasoning Engine ditentukan sebagai class Python. Untuk memberikan contoh, kode Python berikut adalah contoh aplikasi LangChain yang dapat di-deploy di Vertex AI (Anda dapat memberikan nilai variabel CLASS_NAME seperti MyAgent):

from typing import Callable, Sequence

class CLASS_NAME:
    def __init__(
            self,
            model: str,
            tools: Sequence[Callable],
            project: str,
            location: str,
        ):
        self.model_name = model
        self.tools = tools
        self.project = project
        self.location = location

    def set_up(self):
        """All unpickle-able logic should go here.

        The .set_up() method should not be called for an object that is being
        prepared for deployment.
        """
        import vertexai
        from langchain_google_vertexai import ChatVertexAI
        from langchain.agents import AgentExecutor
        from langchain.agents.format_scratchpad.tools import format_to_tool_messages
        from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
        from langchain.tools.base import StructuredTool
        from langchain_core import prompts

        vertexai.init(project=self.project, location=self.location)

        prompt = {
            "input": lambda x: x["input"],
            "agent_scratchpad": (
                lambda x: format_to_tool_messages(x["intermediate_steps"])
            ),
        } | prompts.ChatPromptTemplate.from_messages([
            ("user", "{input}"),
            prompts.MessagesPlaceholder(variable_name="agent_scratchpad"),
        ])

        llm = ChatVertexAI(model_name=self.model_name)
        if self.tools:
            llm = llm.bind_tools(tools=self.tools)

        self.agent_executor = AgentExecutor(
            agent=prompt | llm | ToolsAgentOutputParser(),
            tools=[StructuredTool.from_function(tool) for tool in self.tools],
        )

    def query(self, input: str):
        """Query the application.

        Args:
            input: The user prompt.

        Returns:
            The output of querying the application with the given input.
        """
        return self.agent_executor.invoke(input={"input": input})

Saat menulis class Python, tiga metode berikut penting untuk mesin penalaran:

  1. __init__():
    • Gunakan metode ini hanya untuk parameter konfigurasi aplikasi. Misalnya, Anda dapat menggunakan metode ini untuk mengumpulkan parameter model dan atribut keamanan sebagai argumen input dari pengguna. Anda juga dapat menggunakan metode ini untuk mengumpulkan parameter seperti project ID, region, kredensial aplikasi, dan kunci API.
    • Konstruktor menampilkan objek yang harus "dapat di-pickle" agar dapat di-deploy ke mesin penalaran. Oleh karena itu, Anda harus melakukan inisialisasi klien layanan dan membuat koneksi ke database dalam metode .set_up, bukan dalam metode __init__.
    • Metode ini bersifat opsional. Jika tidak ditentukan, Vertex AI akan menggunakan konstruktor Python default untuk class.
  2. set_up():
    • Anda harus menggunakan metode ini untuk menentukan logika inisialisasi aplikasi. Misalnya, Anda menggunakan metode ini untuk membuat koneksi ke database atau layanan dependen, mengimpor paket dependen, atau melakukan prakomputasi data yang digunakan untuk menayangkan kueri.
    • Metode ini bersifat opsional. Jika tidak ditentukan, Vertex AI akan mengasumsikan bahwa aplikasi tidak perlu memanggil metode .set_up sebelum menayangkan kueri pengguna.
  3. query():
    • Anda harus menggunakan metode ini untuk menentukan logika runtime yang menayangkan kueri pengguna. Misalnya, Anda menggunakan metode ini untuk membuat konten dengan model AI Generatif atau mengambil data real-time dari API eksternal.
    • Metode ini diperlukan. Jika tidak ditentukan, layanan ReasoningEngine akan menampilkan error saat Anda mencoba membuat instance jarak jauh aplikasi.
    • Anda harus memberikan docstring yang jelas ke metode ini yang menentukan fungsinya, mendokumentasikan atributnya, dan memberikan anotasi jenis untuk inputnya. Hindari argumen variabel dalam metode query.

Menguji aplikasi secara lokal

Buat instance aplikasi di memori lokal menggunakan kode berikut:

agent = CLASS_NAME(
    model=model,  # Required.
    tools=[get_exchange_rate],  # Optional.
    project=PROJECT_ID,
    location=LOCATION,
)
agent.set_up()

Anda dapat menguji aplikasi dengan mengirimkan kueri pengujian ke instance lokal:

response = agent.query(
    input="What is the exchange rate from US dollars to Swedish currency?"
)

Responsnya adalah kamus yang mirip dengan berikut ini:

{"input": "What is the exchange rate from US dollars to Swedish currency?",
 # ...
 "output": "For 1 US dollar you will get 10.7345 Swedish Krona."}

Langkah selanjutnya