Agents  상담원

Acknowledgements  감사

Table of contents  목차

This combination of reasoning, logic, and access to external information that are all connected to a Generative Al model invokes the concept of an agent.
이러한 추론, 논리, 외부 정보에 대한 액세스의 조합은 모두 제너레이티브 알 모델에 연결되어 에이전트라는 개념을 불러옵니다.

Introduction  소개

What is an agent?
에이전트란 무엇인가요?

In order to understand the inner workings of an agent, let’s first introduce the foundational components that drive the agent’s behavior, actions, and decision making. The combination of these components can be described as a cognitive architecture, and there are many such architectures that can be achieved by the mixing and matching of these components. Focusing on the core functionalities, there are three essential components in an agent’s cognitive architecture as shown in Figure 1.
에이전트의 내부 작동을 이해하기 위해 먼저 에이전트의 행동, 작업 및 의사 결정을 주도하는 기본 구성 요소를 소개해 보겠습니다. 이러한 구성 요소의 조합을 인지 아키텍처라고 할 수 있으며, 이러한 구성 요소의 혼합과 조합을 통해 달성할 수 있는 아키텍처는 여러 가지가 있습니다. 핵심 기능을 중심으로 에이전트의 인지 아키텍처에는 그림 1과 같이 세 가지 필수 구성 요소가 있습니다.

The model  모델

The tools  도구

The orchestration layer  오케스트레이션 레이어

Agents vs. models  상담원 대 모델

Cognitive architectures: How agents operate
인지 아키텍처: 상담원 운영 방식

• They gather information, like the patron’s order and what ingredients are in the pantry and refrigerator.
  고객의 주문, 식료품 저장실과 냉장고에 어떤 식재료가 있는지 등의 정보를 수집합니다.
• They perform some internal reasoning about what dishes and flavor profiles they can create based on the information they have just gathered.
  방금 수집한 정보를 바탕으로 어떤 요리와 맛 프로필을 만들 수 있는지 내부적으로 추론합니다.
• They take action to create the dish: chopping vegetables, blending spices, searing meat.
  야채를 자르고, 향신료를 섞고, 고기를 굽는 등 요리를 만들기 위한 작업을 수행합니다.

• ReAct, a prompt engineering framework that provides a thought process strategy for language models to Reason and take action on a user query, with or without in-context examples. ReAct prompting has shown to outperform several SOTA baselines and improve human interoperability and trustworthiness of LLMs.
  언어 모델이 사용자 쿼리를 추론하고 조치를 취하기 위한 사고 프로세스 전략을 제공하는 프롬프트 엔지니어링 프레임워크인 ReAct는 문맥에 맞는 예제를 포함하거나 포함하지 않고도 사용자 쿼리를 추론할 수 있습니다. ReAct 프롬프트는 여러 SOTA 기준선을 능가하는 성능을 보였으며, 인간의 상호 운용성과 LLM의 신뢰성을 개선하는 것으로 나타났습니다.
• Chain-of-Thought (CoT), a prompt engineering framework that enables reasoning capabilities through intermediate steps. There are various sub-techniques of CoT including self-consistency, active-prompt, and multimodal CoT that each have strengths and weaknesses depending on the specific application.
  중간 단계를 통해 추론 기능을 구현하는 신속한 엔지니어링 프레임워크인 CoT(Chain-of-Thought)입니다. CoT에는 자체 일관성, 액티브 프롬프트, 멀티모달 CoT 등 다양한 하위 기술이 있으며, 각 기술은 특정 애플리케이션에 따라 장단점이 있습니다.
• Tree-of-thoughts (TOT), a prompt engineering framework that is well suited for exploration or strategic lookahead tasks. It generalizes over chain-of-thought prompting and allows the model to explore various thought chains that serve as intermediate steps for general problem solving with language models.
  생각의 나무(TOT)는 탐색 또는 전략적 탐색 작업에 적합한 프롬프트 엔지니어링 프레임워크입니다. 생각의 사슬 프롬프트를 일반화하여 언어 모델을 사용하여 일반적인 문제 해결을 위한 중간 단계 역할을 하는 다양한 생각의 사슬을 탐색할 수 있도록 합니다.

1. User sends query to the agent
   사용자가 상담원에게 쿼리를 보냅니다.
2. Agent begins the ReAct sequence
   에이전트가 ReAct 시퀀스를 시작합니다.
3. The agent provides a prompt to the model, asking it to generate one of the next ReAct steps and its corresponding output:
   에이전트는 모델에 다음 ReAct 단계 중 하나와 해당 출력을 생성하도록 요청하는 프롬프트를 제공합니다:
   a. Question: The input question from the user query, provided with the prompt
   a. 질문: 사용자 쿼리의 입력 질문으로, 다음과 같은 프롬프트와 함께 제공됩니다.
   b. Thought: The model’s thoughts about what it should do next
   비. 생각: 다음에 해야 할 일에 대한 모델의 생각
   c. Action: The model’s decision on what action to take next
   c. 조치: 다음에 취할 조치에 대한 모델의 결정
   i. This is where tool choice can occur
   i. 여기에서 도구를 선택할 수 있습니다.
   ii. For example, an action could be one of [Flights, Search, Code, None], where the first 3 represent a known tool that the model can choose, and the last represents “no tool choice”
   ii. 예를 들어, 작업은 [항공편, 검색, 코드, 없음] 중 하나이며, 여기서 처음 3개는 모델이 선택할 수 있는 알려진 도구를 나타내고 마지막은 "도구 선택 없음"을 나타냅니다.
   d. Action input: The model’s decision on what inputs to provide to the tool (if any)
   d. 작업 입력: 도구에 어떤 입력을 제공할지에 대한 모델의 결정(있는 경우)
   e. Observation: The result of the action / action input sequence
   e. 관찰: 동작/행동 입력 시퀀스의 결과
   i. This thought / action / action input / observation could repeat $N$$N$NN-times as needed
   i. 이 생각/행동/행동 입력/관찰은 필요에 따라 $N$$N$NN -회 반복될 수 있습니다.
   f. Final answer: The model’s final answer to provide to the original user query
   f. 최종 답변: 원래 사용자 쿼리에 제공할 모델의 최종 답변입니다.
4. The ReAct loop concludes and a final answer is provided back to the user
   ReAct 루프가 종료되고 최종 답변이 사용자에게 다시 제공됩니다.
   

   

Tools: Our keys to the outside world
도구: 외부 세계로 가는 열쇠

Extensions  확장 기능

The easiest way to understand Extensions is to think of them as bridging the gap between an API and an agent in a standardized way, allowing agents to seamlessly execute APIs regardless of their underlying implementation. Let’s say that you’ve built an agent with a goal of helping users book flights. You know that you want to use the Google Flights API to retrieve flight information, but you’re not sure how you’re going to get your agent to make calls to this API endpoint.
확장 기능을 이해하는 가장 쉬운 방법은 표준화된 방식으로 API와 상담원 사이의 간극을 메워 상담원이 기본 구현에 관계없이 API를 원활하게 실행할 수 있도록 하는 것이라고 생각하면 됩니다. 사용자의 항공편 예약을 돕는 것을 목표로 에이전트를 구축했다고 가정해 보겠습니다. Google 항공편 API를 사용하여 항공편 정보를 검색하고 싶지만 상담원이 이 API 엔드포인트를 어떻게 호출하도록 해야 할지 잘 모르겠습니다.

1. Teaching the agent how to use the API endpoint using examples.
   예제를 사용하여 상담원에게 API 엔드포인트 사용 방법을 가르칩니다.
2. Teaching the agent what arguments or parameters are needed to successfully call the API endpoint.
   에이전트에게 API 엔드포인트를 성공적으로 호출하는 데 필요한 인수 또는 매개 변수를 가르칩니다.
   

   

   
   [1] “The get_flights method can be used to get the latest…”
   [1] "get_flights 메서드를 사용하여 최신..."을 가져올 수 있습니다.
   [2] “When the user wants to search for flights, call get_flights …”
   [2] "사용자가 항공편을 검색하려면 get_flights ...를 호출하세요."
   [3] “Input args for get_flights are arg1, arg2, …”
   [3] "get_flights의 입력 인수는 arg1, arg2, ..."

Extensions can be crafted independently of the agent, but should be provided as part of the agent’s configuration. The agent uses the model and examples at run time to decide which Extension, if any, would be suitable for solving the user’s query. This highlights a key strength of Extensions, their built-in example types, that allow the agent to dynamically select the most appropriate Extension for the task.
확장은 상담원과 독립적으로 만들 수 있지만 상담원 구성의 일부로 제공되어야 합니다. 에이전트는 런타임에 모델과 예제를 사용하여 사용자의 쿼리를 해결하는 데 적합한 확장 기능이 있는지 결정합니다. 이는 상담원이 작업에 가장 적합한 확장을 동적으로 선택할 수 있도록 해주는 기본 제공 예제 유형인 확장 기능의 핵심 강점을 강조합니다.

Sample Extensions  샘플 확장 기능

Python
import vertexai
import pprint
PROJECT_ID = "YOUR_PROJECT_ID"
REGION = "us-central1"
vertexai.init(project=PROJECT_ID, location=REGION)
from vertexai.preview.extensions import Extension
extension_code_interpreter = Extension.from_hub("code_interpreter")
CODE_QUERY = """Write a python method to invert a binary tree in O(n) time."""
response = extension_code_interpreter.execute(
    operation_id = "generate_and_execute",
    operation_params = {"query": CODE_QUERY}
    )
print("Generated Code:")
pprint.pprint({response['generated_code']})
# The above snippet will generate the following code.
Generated Code:
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

Python
def invert_binary_tree(root):
    """
    Inverts a binary tree.
    Args:
        root: The root of the binary tree.
    Returns:
            The root of the inverted binary tree.
    """
    if not root:
            return None
    # Swap the left and right children recursively
    root.left, root.right =
invert_binary_tree(root.right), invert_binary_tree(root.left)
    return root
# Example usage:
# Construct a sample binary tree
root = TreeNode(4)
root.left = TreeNode(2)
root.right = TreeNode(7)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right.left = TreeNode(6)
root.right.right = TreeNode(9)
# Invert the binary tree
inverted_root = invert_binary_tree(root)
`..

Functions  기능

1. A model outputs a Function and its arguments, but doesn’t make a live API call.
   모델은 함수와 그 인수를 출력하지만 라이브 API 호출을 수행하지는 않습니다.
2. Functions are executed on the client-side, while Extensions are executed on the agent-side.
   함수는 클라이언트 측에서 실행되는 반면 확장은 에이전트 측에서 실행됩니다.

Using our Google Flights example again, a simple setup for functions might look like the example in Figure 7.
Google 항공편의 예를 다시 사용하면 그림 7의 예시와 같이 간단한 함수 설정이 가능합니다.

• API calls need to be made at another layer of the application stack, outside of the direct agent architecture flow (e.g. a middleware system, a front end framework, etc.)
  API 호출은 직접 에이전트 아키텍처 흐름 외부의 애플리케이션 스택의 다른 계층(예: 미들웨어 시스템, 프런트엔드 프레임워크 등)에서 이루어져야 합니다.
• Security or Authentication restrictions that prevent the agent from calling an API directly (e.g API is not exposed to the internet, or non-accessible by agent infrastructure)
  상담원이 API를 직접 호출할 수 없도록 하는 보안 또는 인증 제한(예: API가 인터넷에 노출되지 않거나 상담원 인프라에서 액세스할 수 없는 경우)
• Timing or order-of-operations constraints that prevent the agent from making API calls in real-time. (i.e. batch operations, human-in-the-loop review, etc.)
  에이전트가 실시간으로 API 호출을 하지 못하도록 하는 타이밍 또는 작업 순서 제약 조건. (예: 배치 작업, 휴먼 인 더 루프 검토 등)
• Additional data transformation logic needs to be applied to the API Response that the agent cannot perform. For example, consider an API endpoint that doesn’t provide a filtering mechanism for limiting the number of results returned. Using Functions on the client-side provides the developer additional opportunities to make these transformations.
  상담원이 수행할 수 없는 추가적인 데이터 변환 로직을 API 응답에 적용해야 합니다. 예를 들어 반환되는 결과의 수를 제한하는 필터링 메커니즘을 제공하지 않는 API 엔드포인트를 생각해 보세요. 클라이언트 측에서 함수를 사용하면 개발자에게 이러한 변환을 수행할 수 있는 추가적인 기회가 제공됩니다.
• The developer wants to iterate on agent development without deploying additional infrastructure for the API endpoints (i.e. Function Calling can act like “stubbing” of APIs)
  개발자는 API 엔드포인트에 대한 추가 인프라를 배포하지 않고 에이전트 개발을 반복하고자 합니다(즉, 함수 호출은 API의 "스터빙"처럼 작동할 수 있음).

While the difference in internal architecture between the two approaches is subtle as seen in Figure 8, the additional control and decoupled dependency on external infrastructure makes Function Calling an appealing option for the Developer.
그림 8에서 볼 수 있듯이 두 접근 방식 간의 내부 아키텍처 차이는 미묘하지만, 외부 인프라에 대한 추가적인 제어와 분리된 종속성으로 인해 함수 호출은 개발자에게 매력적인 옵션입니다.

Use cases  사용 사례

• Crested Butte, Colorado, USA
  크레스티드 뷰트, 콜로라도, 미국
• Whistler, BC, Canada  캐나다 브리티시컬럼비아주 휘슬러
• Zermatt, Switzerland  스위스 체르마트

Unset
function_call {
    name: "display_cities"
    args: {
        "cities": ["Crested Butte", "Whistler", "Zermatt"],
        "preferences": "skiing"
        }
}

This JSON payload is generated by the model, and then sent to our Client-side server to do whatever we would like to do with it. In this specific case, we’ll call the Google Places API to take the cities provided by the model and look up Images, then provide them as formatted rich content back to our User. Consider this sequence diagram in Figure 9 showing the above interaction in step by step detail.
이 JSON 페이로드는 모델에 의해 생성된 다음 클라이언트 측 서버로 전송되어 원하는 작업을 수행합니다. 이 특정 사례에서는 Google Places API를 호출하여 모델이 제공한 도시를 가져와 이미지를 조회한 다음 형식이 지정된 리치 콘텐츠로 사용자에게 다시 제공합니다. 위의 상호 작용을 단계별로 자세히 보여주는 그림 9의 시퀀스 다이어그램을 살펴보세요.

• You want a language model to suggest a function that you can use in your code, but you don’t want to include credentials in your code. Because function calling doesn’t run the function, you don’t need to include credentials in your code with the function information.
  언어 모델에서 코드에 사용할 수 있는 함수를 제안하고 싶지만 코드에 자격 증명을 포함시키고 싶지 않은 경우. 함수 호출은 함수를 실행하지 않으므로 코드에 함수 정보와 함께 자격 증명을 포함할 필요가 없습니다.
• You are running asynchronous operations that can take more than a few seconds. These scenarios work well with function calling because it’s an asynchronous operation.
  몇 초 이상 걸릴 수 있는 비동기 작업을 실행하고 있습니다. 이러한 시나리오는 비동기 작업이기 때문에 함수 호출과 잘 맞습니다.
• You want to run functions on a device that’s different from the system producing the function calls and their arguments.
  함수 호출과 그 인수를 생성하는 시스템과 다른 장치에서 함수를 실행하려고 합니다.

Function sample code  함수 샘플 코드

Python
    def display_cities(cities: list[str], preferences: Optional[str] = None):
    """Provides a list of cities based on the user's search query and preferences.
    Args:
        preferences (str): The user's preferences for the search, like skiing,
        beach, restaurants, bbq, etc.
        cities (list[str]): The list of cities being recommended to the user.
    Returns:
        list[str]: The list of cities being recommended to the user.
    " ""
    return cities

Python
from vertexai.generative_models import GenerativeModel, Tool, FunctionDeclaration
model = GenerativeModel("gemini-1.5-flash-001")
display_cities_function = FunctionDeclaration.from_func(display_cities)
tool = Tool(function_declarations=[display_cities_function])
message = "I'd like to take a ski trip with my family but I'm not sure where
to go."
res = model.generate_content(message, tools=[tool])
print(f"Function Name: {res.candidates[0].content.parts[0].function_call.name}")
print(f"Function Args: {res.candidates[0].content.parts[0].function_call.args}")
> Function Name: display_cities
> Function Args: {'preferences': 'skiing', 'cities': ['Aspen', 'Vail',
'Park City']}

Data stores  데이터 저장소

Consider a common scenario where a developer might need to provide a small amount of additional data to a model, perhaps in the form of spreadsheets or PDFs.
개발자가 모델에 스프레드시트나 PDF 형태로 소량의 추가 데이터를 제공해야 하는 일반적인 시나리오를 생각해 보겠습니다.

Data Stores allow developers to provide additional data in its original format to an agent, eliminating the need for time-consuming data transformations, model retraining, or finetuning. The Data Store converts the incoming document into a set of vector database embeddings that the agent can use to extract the information it needs to supplement its next action or response to the user.
데이터 스토어를 사용하면 개발자가 에이전트에게 원래 형식의 추가 데이터를 제공할 수 있으므로 시간이 많이 걸리는 데이터 변환, 모델 재교육 또는 미세 조정이 필요하지 않습니다. 데이터 스토어는 수신 문서를 일련의 벡터 데이터베이스 임베딩으로 변환하여 에이전트가 다음 작업이나 사용자에 대한 응답을 보완하는 데 필요한 정보를 추출하는 데 사용할 수 있도록 합니다.

Implementation and application
구현 및 적용

• Website content  웹사이트 콘텐츠
• Structured Data in formats like PDF, Word Docs, CSV, Spreadsheets, etc.
  PDF, Word 문서, CSV, 스프레드시트 등과 같은 형식의 구조화된 데이터.
• Unstructured Data in formats like HTML, PDF, TXT, etc.
  HTML, PDF, TXT 등과 같은 형식의 비정형 데이터
  

  

1. A user query is sent to an embedding model to generate embeddings for the query
   사용자 쿼리가 임베딩 모델로 전송되어 쿼리에 대한 임베딩을 생성합니다.
2. The query embeddings are then matched against the contents of the vector database using a matching algorithm like SCaNN
   그런 다음 쿼리 임베딩은 SCaNN과 같은 매칭 알고리즘을 사용하여 벡터 데이터베이스의 콘텐츠와 매칭됩니다.
3. The matched content is retrieved from the vector database in text format and sent back to the agent
   일치하는 콘텐츠가 벡터 데이터베이스에서 텍스트 형식으로 검색되어 상담원에게 다시 전송됩니다.
4. The agent receives both the user query and retrieved content, then formulates a response or action
   상담원은 사용자 쿼리와 검색된 콘텐츠를 모두 수신한 다음 응답 또는 작업을 공식화합니다.
5. A final response is sent to the user
   최종 응답이 사용자에게 전송됩니다.
   

   

Agents  상담원

Tools recap  도구 요약

Enhancing model performance with targeted learning
목표 학습으로 모델 성능 향상

• In-context learning: This method provides a generalized model with a prompt, tools, and few-shot examples at inference time which allows it to learn ‘on the fly’ how and when to use those tools for a specific task. The ReAct framework is an example of this approach in natural language.
  상황에 맞는 학습: 이 방법은 추론 시점에 프롬프트, 도구, 몇 가지 예시를 통해 일반화된 모델을 제공하여 특정 작업에 이러한 도구를 언제 어떻게 사용해야 하는지 '즉시' 학습할 수 있도록 합니다. ReAct 프레임워크는 자연어에서 이 접근 방식의 한 예입니다.
• Retrieval-based in-context learning: This technique dynamically populates the model prompt with the most relevant information, tools, and associated examples by retrieving them from external memory. An example of this would be the ‘Example Store’ in Vertex AI extensions or the data stores RAG based architecture mentioned previously.
  검색 기반 컨텍스트 내 학습: 이 기술은 외부 메모리에서 가장 관련성이 높은 정보, 도구 및 관련 예제를 검색하여 모델 프롬프트를 동적으로 채웁니다. 예를 들어 Vertex AI 확장 기능의 '예제 저장소' 또는 앞서 언급한 데이터 저장소 RAG 기반 아키텍처가 이에 해당합니다.
• Fine-tuning based learning: This method involves training a model using a larger dataset of specific examples prior to inference. This helps the model understand when and how to apply certain tools prior to receiving any user queries.
  미세 조정 기반 학습: 이 방법은 추론하기 전에 특정 사례의 대규모 데이터 세트를 사용하여 모델을 학습시키는 것입니다. 이를 통해 모델은 사용자 쿼리를 받기 전에 특정 도구를 언제, 어떻게 적용해야 하는지 이해할 수 있습니다.

• Imagine a chef has received a specific recipe (the prompt), a few key ingredients (relevant tools) and some example dishes (few-shot examples) from a customer. Based on this limited information and the chef’s general knowledge of cooking, they will need to figure out how to prepare the dish ‘on the fly’ that most closely aligns with the recipe and the customer’s preferences. This is in-context learning.
  셰프가 고객으로부터 특정 레시피(프롬프트), 몇 가지 주요 재료(관련 도구), 몇 가지 예시 요리(몇 컷 예시)를 받았다고 상상해 보세요. 이 제한된 정보와 요리사의 일반적인 요리 지식을 바탕으로 요리사는 레시피와 고객의 선호도에 가장 근접한 요리를 '즉석에서' 준비할 방법을 찾아야 합니다. 이것이 바로 상황 중심 학습입니다.
• Now let’s imagine our chef in a kitchen that has a well-stocked pantry (external data stores) filled with various ingredients and cookbooks (examples and tools). The chef is now able to dynamically choose ingredients and cookbooks from the pantry and better align to the customer’s recipe and preferences. This allows the chef to create a more informed and refined dish leveraging both existing and new knowledge. This is retrieval-based in-context learning.
  이제 다양한 재료와 요리책(예시 및 도구)으로 가득 찬 팬트리(외부 데이터 저장소)가 있는 주방의 요리사를 상상해 봅시다. 이제 셰프는 팬트리에서 재료와 요리책을 동적으로 선택하여 고객의 레시피와 선호도에 더 잘 맞출 수 있습니다. 이를 통해 셰프는 기존 지식과 새로운 지식을 모두 활용하여 더욱 정보에 입각하고 세련된 요리를 만들 수 있습니다. 이것이 바로 검색 기반 인컨텍스트 학습입니다.
• Finally, let’s imagine that we sent our chef back to school to learn a new cuisine or set of cuisines (pre-training on a larger dataset of specific examples). This allows the chef to approach future unseen customer recipes with deeper understanding. This approach is perfect if we want the chef to excel in specific cuisines (knowledge domains). This is finetuning based learning.
  마지막으로, 새로운 요리 또는 요리 세트를 배우기 위해 셰프를 학교로 다시 보냈다고 가정해 봅시다(특정 사례의 대규모 데이터 세트에 대한 사전 교육). 이렇게 하면 셰프가 이전에 보지 못한 고객 레시피에 대해 더 깊이 이해하고 접근할 수 있습니다. 이 접근 방식은 셰프가 특정 요리(지식 영역)에서 탁월한 능력을 발휘하기를 원할 때 적합합니다. 이것이 바로 미세 조정 기반 학습입니다.

Agent quick start with LangChain
LangChain으로 에이전트 빠른 시작

Python

from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool
from langchain_community.utilities import SerpAPIWrapper
from langchain_community.tools import GooglePlacesTool
os.environ["SERPAPI_API_KEY"] = "XXXXX"
os.environ["GPLACES_API_KEY"] = "XXXXX"
@tool
def search(query: str):
    """Use the SerpAPI to run a Google Search."""
    search = SerpAPIWrapper()
    return search.run(query)
@tool
def places(query: str):
    """Use the Google Places API to run a Google Places Query."""
    places = GooglePlacesTool()
    return places.run(query)
model = ChatVertexAI(model="gemini-1.5-flash-001")
tools = [search, places]
query = "Who did the Texas Longhorns play in football last week? What is the
address of the other team's stadium?"
agent = create_react_agent(model, tools)
input = {"messages": [("human", query)]}
for s in agent.stream(input, stream_mode="values"):
    message = s["messages"][-1]
    if isinstance(message, tuple):
        print(message)
    else:
        message.pretty_print()

Unset

=============================== Human Message ==================================
Who did the Texas Longhorns play in football last week? What is the address
of the other team's stadium?
================================= Ai Message ======================================
Tool Calls: search
Args:
    query: Texas Longhorns football schedule
================================= Tool Message ===================================
Name: search
{...Results: "NCAA Division I Football, Georgia, Date..."}
================================== Ai Message =====================================
The Texas Longhorns played the Georgia Bulldogs last week.
Tool Calls: places
Args:
    query: Georgia Bulldogs stadium
================================ Tool Message ====================================
Name: places
{...Sanford Stadium Address: 100 Sanford...}
================================= Ai Message ====================================
The address of the Georgia Bulldogs stadium is 100 Sanford Dr, Athens, GA
30602, USA

Snippet 9. Output from our program in Snippet 8
코드 조각 9. 스니펫 8의 프로그램 출력

Production applications with Vertex Al agents
버텍스 알 에이전트를 사용한 프로덕션 애플리케이션

Agents  상담원

Summary  요약

1. Agents extend the capabilities of language models by leveraging tools to access realtime information, suggest real-world actions, and plan and execute complex tasks autonomously. agents can leverage one or more language models to decide when and how to transition through states and use external tools to complete any number of complex tasks that would be difficult or impossible for the model to complete on its own.
   에이전트는 도구를 활용하여 실시간 정보에 액세스하고, 실제 작업을 제안하고, 복잡한 작업을 자율적으로 계획 및 실행함으로써 언어 모델의 기능을 확장합니다. 에이전트는 하나 이상의 언어 모델을 활용하여 상태 전환 시기와 방법을 결정하고 외부 도구를 사용하여 모델 자체로는 완료하기 어렵거나 불가능한 복잡한 작업을 얼마든지 완료할 수 있습니다.
2. At the heart of an agent’s operation is the orchestration layer, a cognitive architecture that structures reasoning, planning, decision-making and guides its actions. Various reasoning techniques such as ReAct, Chain-of-Thought, and Tree-of-Thoughts, provide a framework for the orchestration layer to take in information, perform internal reasoning, and generate informed decisions or responses.
   에이전트 운영의 중심에는 추론, 계획, 의사 결정을 구조화하고 행동을 안내하는 인지 아키텍처인 오케스트레이션 계층이 있습니다. 리액트, 생각의 사슬, 생각의 나무와 같은 다양한 추론 기법은 오케스트레이션 계층이 정보를 받아들이고 내부 추론을 수행하며 정보에 입각한 결정이나 응답을 생성할 수 있는 프레임워크를 제공합니다.
3. Tools, such as Extensions, Functions, and Data Stores, serve as the keys to the outside world for agents, allowing them to interact with external systems and access knowledge beyond their training data. Extensions provide a bridge between agents and external APIs, enabling the execution of API calls and retrieval of real-time information. functions provide a more nuanced control for the developer through the division of labor, allowing agents to generate Function parameters which can be executed client-side. Data Stores provide agents with access to structured or unstructured data, enabling data-driven applications.
   확장 기능, 함수, 데이터 스토어와 같은 도구는 에이전트가 외부 시스템과 상호 작용하고 트레이닝 데이터 이외의 지식에 액세스할 수 있도록 하는 외부 세계로의 열쇠 역할을 합니다. 확장은 에이전트와 외부 API 간의 가교 역할을 하여 API 호출을 실행하고 실시간 정보를 검색할 수 있도록 하며, 함수는 분업을 통해 개발자에게 보다 미묘한 제어 기능을 제공하여 에이전트가 클라이언트 측에서 실행할 수 있는 함수 매개변수를 생성할 수 있도록 합니다. 데이터 저장소는 상담원에게 정형 또는 비정형 데이터에 대한 액세스를 제공하여 데이터 기반 애플리케이션을 구현할 수 있도록 합니다.

Endnotes  각주

1. Shafran, I., Cao, Y. et al., 2022, ‘ReAct: Synergizing Reasoning and Acting in Language Models’. Available at: https://arxiv.org/abs/2210.03629
   샤프란, I., 카오, Y. 외, 2022, 'ReAct: 언어 모델에서 추론과 행동의 시너지 효과'. 사용 가능: https://arxiv.org/abs/2210.03629
2. Wei, J., Wang, X. et al., 2023, ‘Chain-of-Thought Prompting Elicits Reasoning in Large Language Models’. Available at: https://arxiv.org/pdf/2201.11903.pdf.
   2023, '대규모 언어 모델에서 추론을 유도하는 생각의 연쇄', Wei, J., Wang, X. 외., '대규모 언어 모델에서 추론을 유도하는 생각의 연쇄'. 사용 가능: https://arxiv.org/pdf/2201.11903.pdf.
3. Wang, X. et al., 2022, ‘Self-Consistency Improves Chain of Thought Reasoning in Language Models’. Available at: https://arxiv.org/abs/2203.11171.
   Wang, X. 외, 2022, '자기 일관성은 언어 모델에서 사고 추론의 사슬을 개선합니다'. 사용 가능: https://arxiv.org/abs/2203.11171.
4. Diao, S. et al., 2023, ‘Active Prompting with Chain-of-Thought for Large Language Models’. Available at: https://arxiv.org/pdf/2302.12246.pdf.
   2023, '대규모 언어 모델을 위한 생각의 사슬을 이용한 능동적 프롬프트', Diao, S. 외., 2023. 사용 가능: https://arxiv.org/pdf/2302.12246.pdf.
5. Zhang, H. et al., 2023, ‘Multimodal Chain-of-Thought Reasoning in Language Models’. Available at: https://arxiv.org/abs/2302.00923.
   2023, '언어 모델에서 다중 모드 사고 연쇄 추론'. 이용 가능: https://arxiv.org/abs/2302.00923.
6. Yao, S. et al., 2023, ‘Tree of Thoughts: Deliberate Problem Solving with Large Language Models’. Available at: https://arxiv.org/abs/2305.10601.
   야오, S. 외, 2023, '생각의 나무: 대규모 언어 모델을 사용한 신중한 문제 해결'. 이용 가능: https://arxiv.org/abs/2305.10601.
7. Long, X., 2023, ‘Large Language Model Guided Tree-of-Thought’. Available at: https://arxiv.org/abs/2305.08291.
   Long, X., 2023, '대규모 언어 모델 안내 트리 오브 씽크'. 사용 가능: https://arxiv.org/abs/2305.08291.
8. Google. ‘Google Gemini Application’. Available at: http://gemini.google.com.
   구글. '구글 제미니 애플리케이션'. 사용 가능: http://gemini.google.com.
9. Swagger. ‘OpenAPI Specification’. Available at: https://swagger.io/specification/.
   Swagger. 'OpenAPI 사양'. 사용 가능: https://swagger.io/specification/.
10. Xie, M., 2022, ‘How does in-context learning work? A framework for understanding the differences from traditional supervised learning’. Available at: https://ai.stanford.edu/blog/understanding-incontext/.
    Xie, M., 2022, '맥락 내 학습은 어떻게 작동하나요? 기존 지도 학습과의 차이점을 이해하기 위한 프레임워크'. 사용 가능: https://ai.stanford.edu/blog/understanding-incontext/.
11. Google Research. ‘ScaNN (Scalable Nearest Neighbors)’. Available at: https://github.com/google-research/google-research/tree/master/scann.
    구글 리서치. 'ScaNN (확장 가능한 가장 가까운 이웃)'. 사용 가능: https://github.com/google-research/google-research/tree/master/scann.
12. LangChain. ‘LangChain’. Available at: https://python.langchain.com/v0.2/docs/introduction/.
    LangChain. 'LangChain'. 이용 가능: https://python.langchain.com/v0.2/docs/introduction/.