如何让大模型安全地自动生成代码并执行？

合集 - AI相关(39)

1.与LLMs进行在IDE中直接、无需提示的交互是工具构建者探索的一个有希望的未来方向2024-08-132.将爬虫与大语言模型结合2024-08-143.AvaloniaChat：一个基于大语言模型用于翻译的简单应用2024-08-164.最佳实践：在AvaloniaChat中接入SiliconCloud2024-08-165.AvaloniaChat—从源码构建指南2024-08-186.SimpleRAG：基于WPF与Semantic Kernel实现的一个简单的RAG应用2024-08-197.Semantic Kernel/C#：接入智谱AI的两种方式2024-08-218.AvaloniaChat-v0.0.2：兼容智谱AI 快速使用指南2024-08-219.使用SiliconCloud快速体验SimpleRAG（手把手教程）2024-08-2210.使用Ollama本地离线体验SimpleRAG（手把手教程）2024-08-2311.在NextChat中接入SiliconCloud API 体验不同的开源先进大语言模型2024-08-2612.AI Agents有哪些风险？哪些措施可以减少风险？2024-08-2613.来自OpenAI官网的Function calling介绍与最佳实践2024-08-2814.在LobeChat中使用SiliconCloud，一键拥有你自己的 ChatGPT/Gemini/Claude/Ollama 应用2024-08-2815.Semantic Kernel/C#：一种通用的Function Calling方法，文末附经测试可用的大模型2024-08-2916.在SimpleRAG中使用SiliconCloud快速测试Function Calling2024-08-2917.SimpleTranslationAIAgent：基于C#与LLM的翻译AI Agent2024-08-3118.SimpleTranslationAIAgent借助SiliconCloud API 构建自己的专属翻译助手2024-08-3119.SimpleAISearch：C# + DuckDuckGo 实现简单的AI搜索2024-09-2020.SimpleAIAgent：使用免费的glm-4-flash即可开始构建简单的AI Agent应用2024-09-2521.SimpleRAG-v1.0.3：增加文件对话功能2024-09-2622.如何自己动手实现一个图片解答小助手2024-10-0923.Microsoft.Extensions.AI 初探2024-11-2024.AI工具推荐——Cherry Studio2024-12-0425.AI提效工具推荐——Sider2024-12-0626.VLM-OCR-Demo：一个使用VLM用于OCR任务的示例2024-12-0927.使用C#构建一个论文总结AI Agent01-0228.PaperAssistant：使用Microsoft.Extensions.AI实现01-0429.C# AIModelRouter：使用不同的AI模型完成不同的任务01-0630.AutoGen入门-让两个AI自行聊天完成任务01-0731.DeepSeekV3+Roo Code，智能编码好助手02-0232.使用Chainlit快速构建一个对话式人工智能应用体验DeepSeek-R102-0433.AI工具推荐——open-interpreter02-0834.浏览器自动化与AI Agent结合项目browser-use初探02-1235.AI工具推荐：领先的开源 AI 代码助手——Continue02-1536.Word中接入大模型教程02-1737.使用crewai创建属于你自己的AI团队02-19

38.如何让大模型安全地自动生成代码并执行？02-24

39.创建一个MCP服务器，并在Cline中使用，增强自定义功能。03-02

收起

前言

本文带来的分享是在crewai中使用代码解释器，为了安全，代码在docker中运行。

为什么要使用代码解释器呢？

之前的文章中使用的是function call + 各种工具 来完成一个任务，比如文件读取工具、文件保存工具等。

但是用户的需求是多变的，你很难提前写好所有的工具。

读取文件内容，使用代码解释器的效果如下所示：

实践

首先需要看下crewai中提供的代码解释器工具代码，学习一下。

代码在：https://github.com/crewAIInc/crewAI-tools/tree/main/crewai_tools/tools/code_interpreter_tool

文件如下：

先来看一下Dockerfile：

FROM python:3.12-alpine

RUN pip install requests beautifulsoup4 

# Set the working directory
WORKDIR /workspace

这是一个Dockerfile的片段，用于构建一个Python环境的Docker镜像。解释如下：

FROM python:3.12-alpine：这行指定了基础镜像为Python 3.12版本的Alpine Linux镜像。Alpine Linux是一种轻量级的Linux发行版，非常适合作为Docker镜像的基础。
RUN pip install requests beautifulsoup4：这行使用pip安装两个Python包：requests和beautifulsoup4。requests是一个用于发送HTTP请求的库，而beautifulsoup4是一个用于解析HTML和XML文档的库。
WORKDIR /workspace：这行设置了容器中的工作目录为/workspace。当容器启动时，会自动进入这个目录。
总的来说，这个Dockerfile构建了一个Python环境，安装了两个常用的库，并将工作目录设置为/workspace。这个镜像可以用于运行Python应用程序，尤其是那些需要解析HTML和发送HTTP请求的应用程序。

再来看一下code_interpreter_tool.py的代码：

import importlib.util
import os
from typing import List, Optional, Type
from crewai.tools import BaseTool
from docker import from_env as docker_from_env
from docker import DockerClient
from docker.models.containers import Container
from docker.errors import ImageNotFound, NotFound
from docker.models.containers import Container
from pydantic import BaseModel, Field


class CodeInterpreterSchema(BaseModel):
    """
    Input for CodeInterpreterTool.
    供代码解释工具输入。
    """

    code: str = Field(
        ...,
        # Python3代码原来是在Docker容器中被解释的。始终打印最终结果和代码的输出。
        description="Python3 code used to be interpreted in the Docker container. ALWAYS PRINT the final result and the output of the code",
    )

    libraries_used: Optional[List[str]] = Field(
        None,
        # 代码中使用的库列表，带有适当的安装名称，以逗号分隔。例如： numpy，pandas，beautifulsoup4
        description="List of libraries used in the code with proper installing names separated by commas. Example: numpy,pandas,beautifulsoup4",
    )


class CodeInterpreterTool(BaseTool):
    name: str = "Code Interpreter"
    description: str = "Interprets Python3 code strings with a final print statement."
    args_schema: Type[BaseModel] = CodeInterpreterSchema
    default_image_tag: str = "code-interpreter:latest"
    code: Optional[str] = None
    user_dockerfile_path: Optional[str] = None
    user_docker_base_url: Optional[str] = None
    unsafe_mode: bool = False

    @staticmethod
    def _get_installed_package_path():
        spec = importlib.util.find_spec("crewai_tools")
        return os.path.dirname(spec.origin)

    def _verify_docker_image(self) -> None:
        """
        Verify if the Docker image is available. Optionally use a user-provided Dockerfile.
        验证Docker镜像是否可用。可选地使用用户提供的Dockerfile。
        """

        client = (
            docker_from_env()
            if self.user_docker_base_url == None
            else DockerClient(base_url=self.user_docker_base_url)
        )

        try:
            client.images.get(self.default_image_tag)

        except ImageNotFound:
            if self.user_dockerfile_path and os.path.exists(self.user_dockerfile_path):
                dockerfile_path = self.user_dockerfile_path
            else:
                package_path = self._get_installed_package_path()
                dockerfile_path = os.path.join(
                    package_path, "tools/code_interpreter_tool"
                )
                if not os.path.exists(dockerfile_path):
                    raise FileNotFoundError(
                        f"Dockerfile not found in {dockerfile_path}"
                    )

            client.images.build(
                path=dockerfile_path,
                tag=self.default_image_tag,
                rm=True,
            )

    def _run(self, **kwargs) -> str:
        code = kwargs.get("code", self.code)
        libraries_used = kwargs.get("libraries_used", [])

        if self.unsafe_mode:
            return self.run_code_unsafe(code, libraries_used)
        else:
            return self.run_code_in_docker(code, libraries_used)

    def _install_libraries(self, container: Container, libraries: List[str]) -> None:
        """
        Install missing libraries in the Docker container
        """
        for library in libraries:
            container.exec_run(["pip", "install", library])

    def _init_docker_container(self) -> Container:
        container_name = "code-interpreter"
        client = docker_from_env()
        current_path = os.getcwd()

        # Check if the container is already running
        try:
            existing_container = client.containers.get(container_name)
            existing_container.stop()
            existing_container.remove()
        except NotFound:
            pass  # Container does not exist, no need to remove

        return client.containers.run(
            self.default_image_tag,
            detach=True,
            tty=True,
            working_dir="/workspace",
            name=container_name,
            volumes={current_path: {"bind": "/workspace", "mode": "rw"}},  # type: ignore
        )

    def run_code_in_docker(self, code: str, libraries_used: List[str]) -> str:
        self._verify_docker_image()
        container = self._init_docker_container()
        self._install_libraries(container, libraries_used)

        exec_result = container.exec_run(["python3", "-c", code])

        container.stop()
        container.remove()

        if exec_result.exit_code != 0:
            return f"Something went wrong while running the code: \n{exec_result.output.decode('utf-8')}"
        return exec_result.output.decode("utf-8")

    def run_code_unsafe(self, code: str, libraries_used: List[str]) -> str:
        """
        Run the code directly on the host machine (unsafe mode).
        """
        # Install libraries on the host machine
        for library in libraries_used:
            os.system(f"pip install {library}")

        # Execute the code
        try:
            exec_locals = {}
            exec(code, {}, exec_locals)
            return exec_locals.get("result", "No result variable found.")
        except Exception as e:
            return f"An error occurred: {str(e)}"

主要的参数与描述如下：

code: str = Field(
        ...,
        # Python3代码原来是在Docker容器中被解释的。始终打印最终结果和代码的输出。
        description="Python3 code used to be interpreted in the Docker container. ALWAYS PRINT the final result and the output of the code",
    )

    libraries_used: Optional[List[str]] = Field(
        None,
        # 代码中使用的库列表，带有适当的安装名称，以逗号分隔。例如： numpy，pandas，beautifulsoup4
        description="List of libraries used in the code with proper installing names separated by commas. Example: numpy,pandas,beautifulsoup4",
    )

测试这个工具的代码：

from crewai import LLM, Agent, Crew, Process, Task
# from crewai_tools import CodeInterpreterTool
from code_interpreter_tool import CodeInterpreterTool
import os
from dotenv import load_dotenv
load_dotenv()

api_key = os.getenv('SiliconCloud_API_KEY')
base_url = os.getenv('SiliconCloud_API_BASE')
model = os.getenv('SiliconCloud_MODEL_NAME', 'openai/Qwen/Qwen2.5-72B-Instruct')  # Provide a default model if not set

agent_llm = LLM(
model=model,
base_url=base_url,
api_key=api_key
	)

# Create an LLM with a temperature of 0 to ensure deterministic outputs
# llm = LLM(model="gpt-4o-mini", temperature=0)

# Create an agent with the knowledge store
agent = Agent(
    role="Tool User",
    goal="You know how to use the tool.",
    backstory="""
    You are a master at using the tool.
    使用代码执行工具时，如果没有使用库，则libraries_used参数为空列表，需要写成libraries_used=[]。
    """,
    verbose=True,
    allow_delegation=False,
    llm=agent_llm,
    tools=[CodeInterpreterTool()],
)
task = Task(
    description="""
    根据用户需求：{question}
    使用相应的工具。
    """,
    expected_output="获取本次工具输出的结果，无需其它内容。",
    agent=agent,
)

crew = Crew(
    agents=[agent],
    tasks=[task],
    verbose=True,
    process=Process.sequential,
)

result = crew.kickoff(
    inputs={
        "question": "获取test2.txt的内容"
    }
)

在这个地方可以输入你的需求看看代码解释器能不能实现。

先来一个最简单的：

result = crew.kickoff(
    inputs={
        "question": "输出你好世界"
    }
)

再来一个创建文件的：

result = crew.kickoff(
    inputs={
        "question": "创建test3.txt，里面写入我是一只鱼。"
    }
)

再试一下需要使用库的：

result = crew.kickoff(
    inputs={
        "question": "画一个折线图，横坐标为1月、2月、3月，纵坐标为12、15、17,将结果保存到test.png。"
    }
)

中文字体没有正常显示，修改需求：

画一个折线图，横坐标为1月、2月、3月，纵坐标为12、15、17,需要显示中文字体，将结果保存到test.png。

还是没有成功。

在docker环境中没有安装中文字体。

并且使用代码解释器的一个缺点就是你无法保证AI生成的代码就是能用的，稍微复杂一点的需求，就有可能生成无法运行的代码。

这样来看代码解释器的可玩性还是有很大的限制。

但是确实可以替代一些简单的工具了。