DEVOCEAN

AI Agent 는 어디까지 발전해왔을까?

AI Agent 는 대규모 언어 모델 (LLM: Large Language Model) 을 기반으로 환경을 인지, 분석하고 자율적으로 도구 (Tool) 를 활용하여 목표를 달성하는 지능형 시스템입니다.

2022년~2023년 초기의 에이전트 시스템이 단일 작업 처리에 집중했다면,

현재는 Multi-Tool Orchestration 과 맥락 기반 의사결정 (Context-Aware Decision Making) 기능을 중심으로 발전하고 있습니다.

AI Agent 의 핵심 기술 중 하나인 Tool Calling 은 언어 모델이 외부 도구, API 또는 기타 리소스를 활용하여 정보를 얻거나 작업을 수행할 수 있도록 해주는 혁신적인 기능입니다.

위의 그림은 Tool Calling 프로세스를 표현한 것입니다.

사용자가 애플리케이션에 프롬프트를 입력하면, 애플리케이션은 이를 모델로 전달하고, 필요한 경우 함수 호출(Function Call)을 통해 API와 상호작용합니다.

모델은 함수 식별자와 매개변수를 기반으로 API 요청을 생성하고, API로부터 받은 응답을 처리하여 최종 결과를 사용자에게 반환합니다.

이 과정은 애플리케이션과 모델 간의 협력을 통해 복잡한 작업을 자동화하고 효율적으로 처리하는 데 중점을 둡니다.

그러나, 기존에 사용되던 이러한 Tool Calling 은 다음과 같이 여러 한계가 존재했습니다.

1. 제한된 Tool 세트

   기존의 Tool Calling 은 미리 정의된 함수나 API 에 의존하여, AI 가 수행할 수 있는 작업의 범위를 제한하였습니다.

2. 복잡한 작업 처리의 어려움 & 시각화 능력 부족

   또한 여러 단계의 복잡한 계산이나 데이터 처리, 그리고 데이터를 그래프나 차트로 시각화하는 것과 같은 작업에는 여전히 한계가 있었습니다.

3. 실시간 데이터 처리의 한계

   특히, 동적으로 변하는 데이터나 사용자 입력에 따라 즉시 계산을 수행하는 것이 제한적이었습니다.

이 포스팅에서 소개할 Code Interpreter 기술의 등장으로 이러한 한계를 많은 부분 해결하게 됩니다.

미리 정의된 API 의 입출력에 의존하지 않고, LLM 모델을 사용하여 도구를 동적으로 생성하고 보다 유연한 패러다임으로 발전하게 되었는데요,

이로써 Code Interpreter 는 Tool Calling 매커니즘의 진화를 가져오며 AI Agent 의 기능 범위를 혁신적으로 확장시킬 수 있게 되었습니다.

Code Interpreter 이란?

Code Interpreter 는 사용자의 자연어 명령을 분석하여 Python 코드를 자동으로 생성하고 Sandbox 환경에서 코드를 실행하여 작업을 해결할 수 있는 기술입니다.

Open AI 가 GPT-4 에 최초로 도입한 이 기술은, 동적으로 코드를 생성하는 기능을 포함하고 있다는 점에서 기존의 전통적인 Interpreter 와의 근본적인 차이를 보입니다.

이렇게 Code Interpreter 를 통해 동적으로 생성된 Tool 은 LLM 런타임에 사용자의 프롬프트에 따라 생성한 함수 또는 코드 블록입니다.

즉, 코드베이스에서 모든 가능한 시나리오를 미리 정의할 필요가 없으므로 훨씬 더 개방적이고 창의적인 문제 해결이 가능합니다.

Code Interpreter 의 주요 기능

Code Interpreter 을 통해 실행 가능한 주요 기능들은 다음과 같습니다.

1. 유연한 문제 해결

   Code Interpreter 는 Python 코드를 실시간으로 작성하고 실행할 수 있어, 미리 정의되지 않은 다양한 문제를 Real-time 으로 해결할 수 있습니다.

   이는 사용자의 요구사항이 빠르게 변화하는 상황에서도 새로운 문제 유형에 적응하여 실시간으로 대응이 가능함을 의미합니다.

2. 복잡한 계산 수행

   행렬 계산, 미적분, 통계 분석과 같은 고급 수학적 연산, 데이터 변환과 분석 (대규모 데이터셋 처리), 알고리즘 구현 및 최적화 등 복잡한 작업을 코드로 직접 수행 가능합니다.

   심지어 Code Generation 을 통해 간단한 ML 모델을 자동으로 생성하기도 합니다.

3. 실시간 데이터 처리

   사용자의 입력이나 실시간 데이터를 바로 처리하고 결과 생성이 가능합니다.

   사용자의 입력에 따른 실시간 시뮬레이션이나 스트리밍 데이터의 실시간 처리 및 분석이 가능합니다.

4. 고급 시각화 기능

   Python 의 강력한 시각화 라이브럴 (numpy, pandas, matplotlib 등) 를 활용하여 데이터를 그래프와 차트로 시각화할 수 있습니다.

   이를 통해 복잡한 데이터를 보다 직관적으로 이해할 수 있으며, 데이터 분포를 나타내는 히스토그램 생성, 시간에 따른 변화를 보여주는 선 그래프를 작성하는 등의 작업이 가능합니다.

   
   

5. 파일 처리

   다양한 형식의 파일 업로드 및 처리가 가능하여, 데이터 분석과 조작의 범위가 크게 확장될 수 있습니다.

   특히, 비정형 데이터에서 필요한 정보를 추출하고 정제하는 작업이 가능합니다.

   이를 통해 대규모 데이터를 처리하여 핵심 정보를 요약하거나 이미지나 로그 파일 등의 비정형 데이터를 구조화된 형식으로 변환하는 등의 작업으로도 활용이 가능합니다.

Code Interpreter 은 단순히 코드를 작성하고 실행하는 것을 넘어 사용자의 요구를 실시간으로 이해하고 해결책을 제시할 수 있는 강력한 도구입니다.

AI Agent 에 Code Interpreter 를 적용하기 위한 방법

Code Interpreter 를 AI Agent 의 Tool 로 활용하도록 구현하는 데 있어 가장 중요하게 고려해야 할 점은 보안입니다.

AI 가 동적으로 생성한 코드는 본질적으로 예측이 불가능하며, 의도치 않게 호스트 시스템에 치명적인 손상을 줄 수 있는 악성 코드를 포함할 수 있습니다.

또한 사용자 입력이나 외부 데이터에 의해 영향을 받을 수 있기 때문에, 시스템에 잠재적인 보안 위협이 될 수 있습니다.

따라서, 모든 실행 코드는 “신뢰할 수 없는” 것으로 간주하고 적절한 보안 조치를 취하는 것이 중요합니다.

신뢰할 수 없는 코드로부터 호스트 시스템을 보호하기 위해서는, 코드 실행환경을 철저히 격리해야 합니다.

이는 Sandbox 기술을 통해 구현 가능하며, 호스트 시스템의 무결성을 유지하면서도 AI 의 연산 능력을 최대한 활용할 수 있게 합니다.

Code Interpreter 를 AI Agent 환경에서 안전하게 실행하기 위해서는 다음과 같은 방법을 활용할 수 있습니다.

1. Docker 컨테이너 기반 환경을 자체 구축하여 활용합니다.

   Docker 는 시스템에서 격리된 Linux 환경을 실행할 수 있게 해주는 Containerized 기술입니다.

   이를 통해 Code Interpreter 를 컨테이너 내에서 실행 가능하며, 호스트 시스템과 완전히 격리된 안전한 상태에서 실행됩니다.

   모든 코드 실행은 해당 도커 컨테이너 내에서 이루어지고, 컨테이너는 호스트 시스템에 접근할 수 없습니다.

2. 클라우드 기반 managed 샌드박스 서비스를 이용합니다. 대표적으로는 다음과 같은 서비스들이 있습니다.

   • E2B: https://e2b-blog.framer.website/blog/launching-the-code-interpreter-sdk

   • Riza: https://docs.riza.io/introduction

다음은 E2B Cloud Sandbox 를 이용하였을 때의 아키텍쳐 입니다.

사용자가 AI App 을 호출하면, AI App 은 Code Interpreter SDK 를 통해 E2B Sandbox 에 접근할 수 있으며,

AI App 서버 환경과 Code Interpreter 실행환경인 E2B Sandbox 는 철저하게 분리되어 있습니다.

AI Agent 에 Docker 를 활용한 Code Interpreter 실행 환경 구축

이번 포스팅에서는 첫 번째 방법인 Docker 컨테이너 기반으로 격리된 환경을 구축하여, LangGraph 로 구성된 AI Agent 의 Tool Calling 에 Code Interpreter 를 적용하는 방법을 소개합니다.

가이드는 다음과 같은 3개의 Step 으로 진행됩니다.

(1) Docker Container 기반의 Code Interpreter 실행 환경 구성

(2) Code Interpreter Tool Calling 을 포함한 AI Agent 구성

(3) 동작 테스트 코드 실행

(1) Docker Container 기반의 Code Interpreter 실행 환경 구성

코드 실행을 위해서는 격리된 도커 컨테이너 환경 구성이 필요합니다.

execute_env 폴더를 만들고, 해당 폴더 내에 2개의 파일을 구성합니다.

• requirements.txt : 코드 실행을 위해 필요한 package 정의

• Dockerfile : 코드 실행 환경 구성을 위한 도커 컨테이너 정의

코드 실행을 위해 필요한 Python 패키지 정의

execute_env 폴더를 만들고, 하위에 requirements.txt 파일을 다음과 같이 구성합니다.

numpy==1.21.0
pandas==1.3.0
matplotlib==3.4.3

격리된 코드 실행 환경 구성

다음과 같이 코드 실행 환경 구성을 위한 도커 컨테이너를 정의합니다.

python base 이미지를 이용하고, 위의 (1) 에서 정의한 requirements.txt 파일의 패키지들을 도커 환경에 설치합니다.

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

위의 Dockerfile 을 기반으로, 도커 컨테이너를 빌드합니다.

docker build -t code-executor .

(2) Code Interpreter Tool Calling 을 포함한 AI Agent 구성

AI Agent 는 로컬 (본 가이드에서는 편의상 호스트 시스템을 로컬로 정의) 에서 실행해보도록 하겠습니다.

AI Agent 구성을 위해 다음 두개의 파일을 구성합니다.

• requirements.txt : AI Agent 실행 환경 구성을 위해 필요한 package 정의

• main.py : Code Interpreter Tool Calling 을 테스트하기 위한 샘플 AI Agent 정의

AI Agent 실행 환경 구성을 위한 python 패키지 정의

먼저, AI Agent 실행에 필요한 패키지들을 설치하기 위해, requirement.txt 파일을 다음과 같이 구성합니다.

AI Agent 는 LangGraph 프레임워크를 이용해서 개발할 예정이므로, 아래의 패키지들을 포함합니다.

langgraph
requests
langchain
langchain-openai

Code Sandbox 클래스 정의

코드 실행을 위한 샌드박스 클래스를 정의합니다.

도커 컨테이너 클라이언트를 이용해서 컨테이너를 run 할 수 있으며,

이 때 컨테이너 이미지는 앞서 (1) Docker Container 기반의 Code Interpreter 실행 환경 구성 에서 빌드한 code executor 컨테이너 이미지를 사용합니다.

이를 통해 코드 실행 환경의 격리를 가능하게 합니다.

create_container() 함수에서는 도커 컨테이너를 run 하고, exec_code() 함수에서는 실제로 컨테이너 내에서 코드를 실행하도록 합니다.

# 1. Docker 클라이언트 초기화
docker_client = docker.from_env()

# 2. 코드 샌드박스 관리 클래스
class DockerSandbox:
    def __init__(self):
        self.containers = {}
        
    def create_container(self) -> str:
        container_id = str(uuid.uuid4())
        self.containers[container_id] = docker_client.containers.run(
            image="code-executor”,
            command=["sleep", "3600"],  # 1시간 대기
            detach=True,
            mem_limit="512m",
            cpu_period=50000,
            cpu_quota=25000,
            network_mode="none"
        )
        return container_id
    
    def exec_code(self, container_id: str, code: str) -> str:
        exec_result = self.containers[container_id].exec_run(
            cmd=["python", "-c", code],
            demux=True  # stdout/stderr 분리
        )
        output = exec_result.output[0].decode() if exec_result.output[0] else ""
        error = exec_result.output[1].decode() if exec_result.output[1] else ""
        return f"STDOUT:\n{output}\nSTDERR:\n{error}"

LangGraph Agent 정의

LangGraph 프레임워크를 이용하여 Code Interpreter 를 적용하기 위한 간단한 Agent 를 정의합니다.

# 3. LangGraph 상태 정의
class AgentState(TypedDict):
    messages: Annotated[Sequence[HumanMessage], add_messages]
    session_id: Optional[str]

# 4. Sandbox 정의
sandbox = DockerSandbox()

@tool
def code_interpreter(code: str) -> str:
    """Executes Python code in isolated Docker container"""
    session_id = sandbox.create_container()
    result = sandbox.exec_code(session_id, code)
    return f"Session {session_id}:\n{result}"

# 5. 에이전트 설정
llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [code_interpreter]

# 6. LangGraph 워크플로 구성
graph = StateGraph(AgentState)

def agent_node(state: AgentState):
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

graph.add_node("agent", agent_node)
graph.add_node("tool", ToolNode(tools))

def route_action(state: AgentState) -> str:
    last_msg = state["messages"][-1]
    return "continue" if "tool_calls" in last_msg.additional_kwargs else "end"

graph.set_entry_point("agent")
graph.add_conditional_edges("agent", route_action, {"continue": "tool", "end": END})
graph.add_edge("tool", "agent")

# 7. 그래프 컴파일
app = graph.compile()

Agent 의 StateGraph 는 agent 노드와 code interpreter 을 실행하기 위한 tool 노드 두개를 연결하여 심플하게 구성하였습니다.

(3) 테스트

이제 AI Agent 와 Code Interpreter 실행을 위한 모든 준비가 끝났습니다.

실제로 정의한 Agent 와 Code Interpreter Tool Calling 이 잘 동작하는지 테스트를 해보겠습니다.

테스트 코드 작성

이제 작성한 AI Agent 내에서의 Code Interpreter tool calling 이 잘 동작하는지 확인하기 위해 test_agent.py 파일을 만들고, 다음과 같이 테스트 코드를 작성합니다.

    queries = [
        "Calculate pi using Monte Carlo method",
        "Create a prime number checker function"
    ]
    
    for query in queries:
        print(f"Query: {query}")
        result = app.invoke({
            "messages": [HumanMessage(content=query)]
        })
        print(result["messages"][-1].content)
        print("="*50)

그리고 해당 코드를 AI Agent 의 input 으로 받아, 내부적으로 Code Interpreter 을 활용한 tool calling 을 통해 코드를 실행하게 됩니다.

테스트 코드 실행

독립적으로 파이썬 실행 환경을 관리하기 위해 로컬에서 다음과 같이 Python 가상 환경을 생성하고, AI Agent 실행에 필요한 패키지들을 설치합니다.

python -m venv .venv       # Python 가상 환경 구성
source .venv/bin/activate      # 가상 환경 활성화
pip install -r requirements.txt       # 필요한 Python package 설치

이제 test_agent.py 를 실행하여 테스트 결과를 확인해봅시다!

python test_agent.py

AI Agent 가 사용자의 발화를 받아서 코드를 실시간으로 생성하는 것을 확인할 수 있습니다.

이제 llm_sandbox 라이브러리를 이용하여 격리된 도커 컨테이너 세션을 만들고, 이를 실행하는 과정을 테스트해보겠습니다.

다음과 같이 langchain 기반의 Agent 코드를 작성합니다.

from typing import Optional, List
from llm_sandbox import SandboxSession
from langchain import hub
from langchain_openai import ChatOpenAI
from langchain.tools import tool
from langchain.agents import AgentExecutor, create_tool_calling_agent


@tool
def run_code(lang: str, code: str, libraries: Optional[List] = None) -> str:
    """
    Run code in a sandboxed environment.
    :param lang: The language of the code.
    :param code: The code to run.
    :param libraries: The libraries to use, it is optional.
    :return: The output of the code.
    """
    # Create a new sandbox session
    with SandboxSession(image="python:3.9.19-bullseye", keep_template=True, lang=lang, verbose=False) as session:  # type: ignore[attr-defined]
        return session.run(code, libraries).text
    
    # With custom Dockerfile
    with SandboxSession(dockerfile="Dockerfile", keep_template=True, lang="python") as session:
        result = session.run("print('Hello, World!')")
        print(result)


if __name__ == "__main__":
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    prompt = hub.pull("hwchase17/openai-functions-agent")
    tools = [run_code]

    agent = create_tool_calling_agent(llm, tools, prompt)
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
    output = agent_executor.invoke(
        {
            "input": "Write python code to calculate Pi number by Monte Carlo method then run it."
        }
    )
    print(output)

    output = agent_executor.invoke(
        {
            "input": "Write python code to calculate the factorial of a number then run it."
        }
    )
    print(output)

    output = agent_executor.invoke(
        {"input": "Write python code to calculate the Fibonacci sequence then run it."}
    )
    print(output)

동적으로 정의된 파이썬 코드를 격리된 환경에서 코드 실행한 후 결과를 성공적으로 반환하는 것을 볼 수 있습니다.

이렇게 Code Interpreter 을 도커 컨테이너를 활용하여 AI Agent 에 적용하는 방법까지 알아보았는데요.

실 서비스에서의 상용화를 위해서는 다중 사용자 환경에서의 컨테이너 라이프사이클 관리 역시 중요할 것 입니다.

도커 컨테이너 단위 실행을 기본으로 하되, 쿠버네티스를 활용한 사용자별 컨테이너 풀을 동적으로 확장 또는 축소하는 아키텍쳐도 필요하며,

멀티 테넌트 간 Role-Based Access Control 을 통해 테넌트 간 데이터 격리를 보장해야 하는 등 다양한 요소들이 추가로 고려되어야 할 것 입니다.

Code Interpreter 의 등장과 AI Agent 의 미래

Code Interpreter 의 등장으로, LLM 오케스트레이션 레이어의 진화와 함께 프롬프트 체이닝 및 메모리 관리 기술을 기반으로 "실행 → 피드백 → 재생성" 사이클을 완전 자동화하는 자기 진화형 시스템으로 발전할 것입니다. 

이를 통해 복잡한 데이터 분석부터 보안 취약점 진단까지 도메인 간 문제 해결을 위한 실시간 최적화가 가능해지며, 인간의 창의적 기획과 AI의 정밀한 실행력이 결합된 하이브리드 인텔리전스 시대를 열게 될 것입니다.