TableGPT Agent

https://github.com/tablegpt/tablegpt-agent
Admin
TableGPT Agent is a pre-built agent for TableGPT2, providing an interface for table-based question...
Tokens:17,704
Snippets:177
Trust Score:8.1
License:Apache-2.0
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install tablegpt-agent with Local Mode

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/code-sandbox.md

Install the library with local mode support using pip.

```sh
pip install tablegpt-agent[local]
```

--------------------------------

### Install Langchain

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/retrieval.ipynb

Install the langchain package, which is essential for building retrieval-augmented workflows.

```sh
pip install langchain
```

--------------------------------

### Run Python Code in Local Sandbox

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/code-sandbox.md

Initialize a local sandbox manager, start a sandbox environment, execute Python code, and retrieve results. Ensure pybox library is installed.

```python
from uuid import uuid4
from pybox import LocalPyBoxManager, PyBoxOut

# Initialize the local sandbox manager
pybox_manager = LocalPyBoxManager()

# Assign a unique Kernel ID for the sandbox
kernel_id = str(uuid4())

# Start the sandbox environment
box = pybox_manager.start(kernel_id)

# Define the test code to execute
test_code = """
import math
result = math.sqrt(16)
result
"""

# Run the code in the sandbox
out: PyBoxOut = box.run(code=test_code)

# Print the execution result
print(out)
```

--------------------------------

### Install TableGPT Agent with Local Support

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/quick-start.ipynb

Install TableGPT Agent with optional dependencies for local environment execution.

```python
%pip install tablegpt-agent[local]
```

--------------------------------

### Create and Run Remote Sandbox

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/code-sandbox.md

Demonstrates how to initialize a RemotePyBoxManager, start a remote sandbox, execute Python code within it, and print the results. Replace 'http://example.com' with your actual Enterprise Gateway service address.

```python
from uuid import uuid4
from pybox import RemotePyBoxManager, PyBoxOut

# Initialize the remote sandbox manager, replacing with the actual Enterprise Gateway service address
pybox_manager = RemotePyBoxManager(host="http://example.com")

# Assign a unique Kernel ID
kernel_id = str(uuid4())

# Start the remote sandbox environment
box = pybox_manager.start(kernel_id)

# Define the test code
test_code = """
import math
result = math.sqrt(16)
result
"""

# Run the code in the sandbox
out: PyBoxOut = box.run(code=test_code)

# Print the execution result
print(out)
```

--------------------------------

### Example Data Retrieval Output

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/agent-workflow.md

This output shows example retrieved column information that aids in understanding the dataset for the LLM.

```python
Here are some extra column information that might help you understand the dataset:\n- titanic.csv:\n  - {"column": Sex, "dtype": "string", "values": ["male", "female", ...]}
```

--------------------------------

### Install Evaluation Dependencies

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/realtabbench/agent_eval/README.md

Installs the necessary Python packages for running evaluations from the requirements.txt file.

```sh
pip install -r requirements.txt
```

--------------------------------

### Install Langchain OpenAI

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/quick-start.ipynb

Install the langchain-openai package, required for using OpenAI chat models.

```python
%pip install langchain-openai
```

--------------------------------

### Start vLLM OpenAI-Compatible Server

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/quick-start.ipynb

Launch a vLLM server compatible with the OpenAI API to host the TableGPT2 model. Ensure vLLM version 0.5.5 or higher is used for tabular data analysis.

```bash
python -m vllm.entrypoints.openai.api_server --served-model-name TableGPT2-7B --model path/to/weights
```

--------------------------------

### Install TableGPT Agent

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/quick-start.ipynb

Install the core TableGPT Agent package using pip.

```python
%pip install tablegpt-agent
```

--------------------------------

### Create and Run Cluster Sandbox

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/code-sandbox.md

Shows how to initialize a KubePyBoxManager for a Kubernetes cluster environment, start a sandbox, execute Python code, and print the results. Ensure the jupyter-kernel-controller is deployed and running. Replace placeholder paths and dictionary for environment variables.

```python
from uuid import uuid4
from pybox import KubePyBoxManager, PyBoxOut

# Initialize the cluster sandbox manager, replacing with actual paths and environment variable configurations
pybox_manager = KubePyBoxManager(
    env_file="YOUR_ENV_FILE_PATH",  # Path to the environment variable file
    kernel_env="YOUR_KERNEL_ENV_DICT",  # Kernel environment variable configuration
)

# Assign a unique Kernel ID
kernel_id = str(uuid4())

# Start the cluster sandbox environment
box = pybox_manager.start(kernel_id)

# Define the test code
test_code = """
import math
result = math.sqrt(16)
result
"""

# Run the code in the sandbox
out: PyBoxOut = box.run(code=test_code)

# Print the execution result
print(out)
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/realtabbench/README.md

Clone the tablegpt-agent repository and install the necessary dependencies for the realtabbench evaluation framework.

```shell
git clone https://github.com/tablegpt/tablegpt-agent
cd realtabbench
pip install -r requirements.txt
```

--------------------------------

### Create TruncationConfig for LLM

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Configure truncation settings for language models. This example uses message length as the truncation method, sets a maximum of 5 tokens, and starts truncation from human messages.

```python
# token_counter=len, uses message length as truncation method
# max_tokens=5, maximum length of messages after truncation
# start_on="human", start truncation from human messages
llm_truncation_config = TruncationConfig(token_counter=len, max_tokens=5, start_on="human")
```

--------------------------------

### Invoke Agent with Messages and Handle Output

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Prepare input including messages, parent ID, and date, then invoke the agent. This example demonstrates how to catch potential exceptions during invocation and print the last message content from the response.

```python
_input = {
    "messages": messages,
    "parent_id": "some-parent-id",
    "date": date.today(),  # noqa: DTZ011
}
try:
    res = await agent.ainvoke(input=_input)
    print(res["messages"][-1].content)
except Exception as e:
    print(e)
```

--------------------------------

### Create Async Checkpointer and Invoke Graph

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/persist-messages.ipynb

This snippet demonstrates creating an asynchronous checkpointer using a connection string and then invoking a LangGraph. Useful for quick setups where connection details are readily available.

```python
from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
from tablegpt.agent import create_tablegpt_graph

config = {"configurable": {"thread_id": "2"}}

async with AsyncPostgresSaver.from_conn_string(DB_URI) as checkpointer:
    graph = create_tablegpt_graph(
        llm=llm,
        pybox_manager=pybox_manager,
        checkpointer=checkpointer,
    )
    
    res = await graph.ainvoke(
        input={
            "messages": [("human", "Who are you?")],
            "parent_id": "2",
            "date": date.today()
        },
        config=config,
    )
    checkpoint_tuples = [c async for c in checkpointer.alist(config)]
```

```python
checkpoint_tuples
```

--------------------------------

### Install Agent Evaluation Dependencies

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/realtabbench/README.md

Navigate to the agent_eval directory and install the required Python packages for running agent evaluations.

```bash
cd realtabbench/agent_eval
pip install -r requirements.txt
```

--------------------------------

### Initialize TableGPT Agent with MemorySaver Checkpointer

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/persist-messages.ipynb

Set up a TableGPT agent with a MemorySaver checkpointer for in-memory message persistence. Ensure you have the necessary libraries installed.

```python
from datetime import date

from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver
from tablegpt.agent import create_tablegpt_graph
from pybox import AsyncLocalPyBoxManager

llm = ChatOpenAI(openai_api_base="YOUR_VLLM_URL", openai_api_key="whatever", model_name="TableGPT2-7B")
pybox_manager = AsyncLocalPyBoxManager()
checkpointer = MemorySaver()

graph = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager,
    checkpointer=checkpointer,
)
```

--------------------------------

### Install Packages for Postgres Checkpointer

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/persist-messages.ipynb

Install the necessary Python packages to use PostgreSQL for persisting TableGPT agent checkpoint states.

```python
%pip install -U psycopg psycopg-pool psycopg_binary langgraph langgraph-checkpoint-postgres
```

--------------------------------

### Conduct Initial Conversation with TableGPT

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/persist-messages.ipynb

Invoke the TableGPT agent with an initial human message and a thread ID to start a conversation. The `config` parameter is crucial for persistence.

```python
resp = await graph.ainvoke(
    input={
        "messages": [("human", "Please introduce Jackie Chan")],
        "parent_id": "1",
        "date": date.today(),
    },
    config={\"configurable\": {\"thread_id\": \"1\"}},
)
resp["messages"][-1]
```

--------------------------------

### Install Chinese Fonts for Matplotlib

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/continue-analysis-on-generated-charts.ipynb

Install necessary Chinese fonts for Matplotlib and initialize font settings. This is a prerequisite for displaying Chinese characters correctly in plots.

```bash
apt-get update && apt-get install -y --no-install-recommends fonts-noto-cjk
mplfonts init
```

--------------------------------

### Continue Data Analysis with Agent

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/chat-on-tabular-data.ipynb

Send a follow-up question to the agent after initial data inspection. This example shows how to use `astream_events` to process the agent's response, including handling chat model outputs and tool streams.

```python
human_message = HumanMessage(content="How many men survived?")

async for event in agent.astream_events(
    input={
        # After using checkpoint, you only need to add new messages here.
        "messages": [human_message],
        "parent_id": "some-parent-id2",
        "date": date.today(),
    },
    version="v2",
    # We configure the same thread_id to use checkpoints to retrieve the memory of the last run.
    config={"configurable": {"thread_id": "some-thread-id"}},
):
    event_name: str = event["name"]
    evt: str = event["event"]
    if evt == "on_chat_model_end":
        print(event["data"]["output"])
    elif event_name == "tool_node" and evt == "on_chain_stream":
```

--------------------------------

### Integrate with TableGPT Agent

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/retrieval.ipynb

Integrate the dataset_retriever with the TableGPT Agent using an LLM and a local execution environment. This setup allows the agent to effectively handle user queries by leveraging both LLM and retrieved dataset context.

```python
from langchain_openai import ChatOpenAI
from pybox import AsyncLocalPyBoxManager
from tablegpt.agent import create_tablegpt_graph
from tablegpt import DEFAULT_TABLEGPT_IPYKERNEL_PROFILE_DIR

llm = ChatOpenAI(openai_api_base="YOUR_VLLM_URL", openai_api_key="whatever", model_name="TableGPT2-7B")
pybox_manager = AsyncLocalPyBoxManager(profile_dir=DEFAULT_TABLEGPT_IPYKERNEL_PROFILE_DIR)

agent = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager,
    dataset_retriever=dataset_retriever,
)
```

--------------------------------

### Load Data with CSVLoader

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/retrieval.ipynb

Use CSVLoader to load data from CSV or Excel files into a format suitable for RAG. This example demonstrates lazy loading and initializing an in-memory vector store with an embedding model.

```python
from langchain_core.vectorstores import InMemoryVectorStore
from tablegpt.retriever import CSVLoader

loader = CSVLoader("产品销量表.csv", autodetect_encoding=True)

documents = []
async for item in loader.alazy_load():
    documents.append(item)

# Initialize with an embedding model
vector_store = InMemoryVectorStore(embedding=SomeEmbeddingModel())

await vector_store.aadd_documents(documents=documents)
dataset_base_retriever = vector_store.as_retriever()
```

--------------------------------

### Stream TableGPT Agent Events

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/quick-start.ipynb

Use the `astream_events` method to stream events from the TableGPT Agent, allowing for real-time monitoring of the agent's process. This example prints the output when the chat model interaction ends.

```python
async for event in agent.astream_events(
    input=_input,
    version="v2",
):
    # We ignore irrelevant events here.
    if event["event"] == "on_chat_model_end":
        print(event["data"]["output"])
```

--------------------------------

### Create Virtual Environment and Activate

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/realtabbench/agent_eval/README.md

Sets up a Python virtual environment and activates it. Use the Windows-specific command if on a Windows machine.

```sh
python -m venv venv
source ./venv/bin/activate  # On Windows, use `.\venv\Scripts\activate`
```

--------------------------------

### Initialize Visual Language Model (VLM)

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/continue-analysis-on-generated-charts.ipynb

Set up an instance of the Visual Language Model (VLM) by providing its API base URL and model name. This VLM will be used to interpret and summarize generated visualizations.

```python
# Initialize the VLM instance
vlm = ChatOpenAI(openai_api_base="YOUR_VLM_URL", openai_api_key="whatever", model_name="YOUR_MODEL_NAME")
```

--------------------------------

### Set Up Async Database Connection URI

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/persist-messages.ipynb

Define the database connection URI for PostgreSQL. Ensure the `DB_URI` includes correct authentication, host, and database name. The `sslmode=disable` parameter is used here for simplicity; adjust as needed for secure connections.

```python
DB_URI = "postgresql://postgres:postgres@127.0.0.1:5432/postgres?sslmode=disable"
```

--------------------------------

### Initialize TableGPT Agent with LLM and PyBox

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/continue-analysis-on-generated-charts.ipynb

Set up the TableGPT agent by initializing the language model (LLM) and a PyBox manager. This code configures the agent for data analysis tasks, including file reading capabilities.

```python
from datetime import date
from typing import TypedDict

from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver
from pybox import AsyncLocalPyBoxManager
from tablegpt import DEFAULT_TABLEGPT_IPYKERNEL_PROFILE_DIR
from tablegpt.agent import create_tablegpt_graph
from tablegpt.agent.file_reading import Stage

llm = ChatOpenAI(openai_api_base="YOUR_VLLM_URL", openai_api_key="whatever", model_name="TableGPT2-7B")
pybox_manager = AsyncLocalPyBoxManager(profile_dir=DEFAULT_TABLEGPT_IPYKERNEL_PROFILE_DIR)
checkpointer = MemorySaver()

agent = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager,
    checkpointer=checkpointer,
    session_id="some-session-id", # This is required when using file-reading
)

class Attachment(TypedDict):
    """Contains at least one dictionary with the key filename."""
    filename: str

attachment_msg = HumanMessage(
    content="",
    # Please make sure your iPython kernel can access your filename.
    additional_kwargs={"attachments": [Attachment(filename="titanic.csv")]},
)

# Reading and processing files.
response = await agent.ainvoke(
    input={
        "entry_message": attachment_msg,
        "processing_stage": Stage.UPLOADED,
        "messages": [attachment_msg],
        "parent_id": "some-parent-id1",
        "date": date.today(),
    },
    config={
        # Using checkpointer requires binding thread_id at runtime.
        "configurable": {"thread_id": "some-thread-id"},
    },
)
```

--------------------------------

### Initialize TableGPT Agent with Checkpointer and Session ID

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/chat-on-tabular-data.ipynb

Set up the TableGPT agent for data analysis. Ensure `checkpointer` is a `BaseCheckpointSaver` instance and `session_id` is provided for session persistence. Replace 'YOUR_VLLM_URL' with your actual vLLM endpoint.

```python
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver
from pybox import AsyncLocalPyBoxManager
from tablegpt import DEFAULT_TABLEGPT_IPYKERNEL_PROFILE_DIR
from tablegpt.agent import create_tablegpt_graph

llm = ChatOpenAI(openai_api_base="YOUR_VLLM_URL", openai_api_key="whatever", model_name="TableGPT2-7B")
pybox_manager = AsyncLocalPyBoxManager(profile_dir=DEFAULT_TABLEGPT_IPYKERNEL_PROFILE_DIR)
checkpointer = MemorySaver()

agent = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager,
    checkpointer=checkpointer,
    session_id="some-session-id", # This is required when using file-reading
)
```

--------------------------------

### Initialize Agent with VLM Support

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/continue-analysis-on-generated-charts.ipynb

Create a TableGPT graph agent with Large Language Model (LLM), Pybox manager, Vision Language Model (VLM), and a checkpointer. Assumes llm, pybox_manager, vlm, and checkpointer are defined elsewhere.

```python
agent_with_vlm = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager,
    vlm=vlm,
    checkpointer=checkpointer,
    session_id="some-session-id",
)
```

--------------------------------

### Define Long Message History

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Construct a list of messages representing a long conversation history, including SystemMessage, HumanMessage, and AIMessage. This example demonstrates a lengthy exchange that might exceed token limits.

```python
messages = [
    SystemMessage(content="你是一个友好的AI助手"),
    HumanMessage(content="你能给我讲一个关于大语言模型的故事吗？"),
    AIMessage(content="当然可以。让我们从大语言模型的起源开始讲起。一切要从2017年谷歌提出的Transformer架构说起。这个创新性的架构为后来的GPT、BERT等模型奠定了基础。Transformer架构引入了自注意力机制，能够更好地处理序列数据中的长距离依赖关系。这一突破性进展使得模型能够更好地理解文本的上下文语境，为自然语言处理领域带来了革命性的变化。在此基础上，OpenAI于2018年发布了第一代GPT模型，随后又相继推出了GPT-2和GPT-3，每一代都在规模和性能上有显著提升。同时，谷歌推出的BERT模型采用了双向编码器架构，在多个自然语言理解任务上取得了突破性进展。这些模型的成功激发了更多研究者和机构投入到大语言模型的研发中，推动了整个领域的快速发展。现在，我们已经看到像GPT-4这样的模型展现出令人惊叹的能力，不仅能够进行基础的文本生成，还能够理解上下文、进行推理、解决复杂问题，甚至展现出一定程度的创造力..."),
    
    HumanMessage(content="那AI是如何学习理解人类语言的呢？"),
    AIMessage(content="这是个很好的问题。AI通过大量的文本数据训练来理解语言。它使用自注意力机制来捕捉词语之间的关系，通过预训练和微调两个阶段，逐步掌握语言的规律。在预训练阶段，模型会阅读海量的文本，学习语言的基本模式。这个过程就像一个婴儿通过观察和模仿来学习语言一样。模型会分析数十亿甚至数千亿个词语，理解它们之间的关联和使用规律。在这个过程中，模型会建立起一个复杂的神经网络，每个神经元都负责捕捉特定的语言特征。通过反向传播算法，模型不断调整其内部参数，以更好地预测和理解语言。在微调阶段，模型会针对特定任务进行专门训练，比如问答、摘要生成或情感分析等。这就像人类在掌握基本语言能力后，进一步学习专业词汇和特定领域的表达方式。模型通过大量的实例学习，逐渐理解语言中的细微差别，包括语境、语气、隐含意义等。这个学习过程是持续的，模型通过不断接触新的语言样本来完善自己的理解能力..."),
    
    HumanMessage(content="训练过程中会遇到什么挑战？"),
    AIMessage(content="训练大语言模型面临着多重挑战。首先是计算资源的需求，训练大模型需要数千台GPU和数月时间。这不仅带来了巨大的经济成本，还面临着能源消耗和环境影响的问题。一个大型语言模型的训练可能消耗数百万度电，相当于数千个家庭一年的用电量。其次是高质量数据的获取和处理问题。模型需要海量的训练数据，但这些数据必须经过严格的筛选和清洗。数据中可能包含偏见、歧视、不当内容等有害信息，如果不经过处理，这些问题会被模型学习并在输出中体现出来。此外，数据的多样性和代表性也是一个重要问题，需要确保数据能够覆盖不同语言、文化和领域的知识。在训练过程中，还面临着模型优化的技术挑战，比如梯度消失、过拟合、训练不稳定等问题。这需要研究人员不断改进训练算法和策略。另外，模型的知识更新也是一个持续的挑战，因为世界在不断变化，新的信息和知识在不断产生，如何让模型保持最新的知识状态是一个重要问题..."),
    
    HumanMessage(content="大语言模型是如何生成回答的？"),
    AIMessage(content="大语言模型生成回答的过程非常有趣且复杂。当模型收到一个问题或提示时，它首先会通过其编码器将输入转换为高维向量表示。这个过程中，模型会考虑输入的每个词语及其上下文关系。通过多层自注意力机制，模型能够理解输入中的关键信息和语义结构。在生成回答时，模型会一个词一个词地预测最合适的内容。每生成一个词，都会基于之前生成的所有内容和原始输入来决定下一个最合适的词。这个过程使用了复杂的概率分布计算，模型会为词表中的每个候选词计算一个概率分数，然后选择最合适的词。这种选择不仅要考虑语法正确性，还要考虑语义连贯性和上下文相关性。模型还会使用注意力机制来关注输入中的不同部分，确保生成的内容与问题相关。在生成过程中，模型会维护一个内部状态，这个状态包含了之前生成内容的信息，帮助确保整个回答的连贯性和完整性。同时，模型还会使用各种策略来控制生成的质量，比如温度参数来调节创造性，或使用束搜索等技术来优化输出质量..."),
    
    HumanMessage(content="它们真的理解我们说的话吗？"),
    AIMessage(content="这涉及到AI意识和理解力的哲学问题，这是一个复杂且富有争议的话题。虽然大语言模型能够产生看似智能的回答，但它们是否真正'理解'仍然存在很大争议。从技术角度来看，这些模型本质上是非常复杂的统计模型，它们通过分析大量文本数据中的模式来生成回应。它们的'理解'更像是一种高级的模式匹配和概率预测，而不是像人类那样具有真正的理解和意识。人类的理解涉及到感知、经验、情感和意识等多个层面，而AI目前还无法真正复制这些特质。例如，当我们理解'苹果'这个词时，我们不仅知道它的字面含义，还能联想到它的味道、触感、气味，以及与之相关的个人经历和情感。而AI模型只能基于文本数据中的统计关系来处理这个词。此外，人类的理解还包括常识推理、因果关系理解、情境适应等能力，这些都是当前AI系统还难以完全掌握的。虽然模型可以生成符合语法和语义的回答，但它们可能缺乏真正的理解深度，有时会产生表面上合理但实际上没有意义的回答..."),
    
    HumanMessage(content="未来大语言模型会变得更强大吗？"),
    AIMessage(content="随着技术进步，大语言模型的能力确实在不断提升，未来发展前景令人期待。从技术层面来看，我们正在见证模型规模的持续增长，算法的不断改进，以及训练数据的持续扩充。未来的发展方向可能包括多个突破性的领域：首先是多模态理解能力的提升，未来的模型不仅能处理文本，还能更好地理解图像、音频、视频等多种形式的信息，实现跨模态的理解和生成。其次是持续学习能力的发展，使模型能够像人类一样不断学习和更新知识，而不是停留在训练时的知识状态。在推理能力方面，未来的模型可能会具备更强的逻辑推理、因果推理和抽象思维能力，能够处理更复杂的问题和任务。此外，模型的效率也会得到提升，通过更先进的架构设计和训练方法，实现更低的计算成本和能源消耗。在应用领域，我们可能会看到更专业化的模型出现，针对特定领域如医疗、法律、科研等提供更精准的服务。同时，模型的可解释性和可控性也会得到改善，使其决策过程更透明、更可靠..."),
    
    HumanMessage(content="我们应该如何负责任地使用AI技术？"),
    AIMessage(content="这需要我们在多个层面做出努力，构建一个负责任的AI使用生态系统。首先在技术层面，我们需要确保AI系统的安全性和可控性。这包括开发强大的安全机制，防止系统被滥用或产生有害输出；建立有效的监测和控制机制，确保系统行为符合预期；实施严格的测试和验证流程，评估系统的可靠性和稳定性。在伦理层面，我们需要建立完善的使用准则和监管框架。这包括制定明确的AI伦理原则，规范AI的开发和使用；建立行业标准和最佳实践指南；设立独立的监督机构，确保AI技术的使用符合公共利益。在隐私保护方面，我们需要采取严格的数据保护措施，确保用户数据的安全性和隐私性；建立透明的数据使用政策；给予用户对其数据的控制权。在偏见消除方面，我们需要持续努力提高训练数据的多样性和代表性；开发更公平的算法；定期评估和消除系统中的偏见。在环境影响方面，我们需要关注AI系统的能源消耗和碳排放；开发更环保的计算方案；推动绿色AI技术的发展..."),
    
    HumanMessage(content="你觉得AI会取代人类吗？"),
    AIMessage(content="AI不应该也不会完全取代人类，这个问题需要从多个角度深入思考。首先，虽然AI在某些特定任务上可能超越人类，但人类具有许多AI难以复制的独特优势。人类的创造力是独特的，我们能够产生原创性的想法，进行艺术创作，提出创新性的解决方案。人类的情感共鸣能力也是无可替代的，我们能够理解和分享他人的情感，建立深层的情感联系，这是当前AI技术远远无法达到的。在道德判断和价值观方面，人类能够基于复杂的伦理考虑做出决策，而AI系统往往难以处理需要道德权衡的情况。此外，人类具有自主意识和主观体验，这些都是AI所不具备的特质。未来的发展方向应该是人机协作，让AI成为增强人类能力的工具，而不是替代品。在这种协作模式下，AI可以处理重复性、计算密集型的任务，而人类则专注于需要创造力、情感理解和道德判断的工作。我们需要明智地使用AI技术，确保它始终服务于人类福祉，而不是反过来控制或限制人类的发展...",
    HumanMessage(content="你认为未来的AI会怎么发展？")
]
```

--------------------------------

### Create TableGPT Agent Instance

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/quick-start.ipynb

Instantiate the TableGPT Agent using a configured LLM and a PyBox manager. Replace YOUR_VLLM_URL with your vLLM server endpoint.

```python
from langchain_openai import ChatOpenAI
from pybox import AsyncLocalPyBoxManager
from tablegpt.agent import create_tablegpt_graph


llm = ChatOpenAI(openai_api_base="YOUR_VLLM_URL", openai_api_key="whatever", model_name="TableGPT2-7B")
pybox_manager = AsyncLocalPyBoxManager()

agent = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager,
)
```

--------------------------------

### Import necessary libraries for message truncation

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Import `HumanMessage`, `AIMessage`, `SystemMessage` for message types, `ChatOpenAI` for the LLM service, `create_tablegpt_graph` for agent creation, and `AsyncLocalPyBoxManager` for asynchronous operations.

```python
from datetime import date

from langchain_core.messages import HumanMessage,AIMessage,SystemMessage
from langchain_openai import ChatOpenAI
from tablegpt.agent import create_tablegpt_graph
from pybox import AsyncLocalPyBoxManager
pybox_manager = AsyncLocalPyBoxManager()
```

--------------------------------

### Clean DataFrame and Get Info

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/file-reading.ipynb

This code cleans the DataFrame by stripping whitespace from column names, removing entirely empty rows and columns, and then displays detailed information about the DataFrame's structure, including column data types and non-null counts.

```python
# Remove leading and trailing whitespaces in column names
df1.columns = df1.columns.str.strip()

# Remove rows and columns that contain only empty values
df1 = df1.dropna(how='all').dropna(axis=1, how='all')

# Get the basic information of the dataset
df1.info(memory_usage=False)
```

--------------------------------

### Create TableGPT Agent with Dataset Normalizer

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/normalize-datasets.ipynb

Instantiate the tablegpt-agent, enabling the Dataset Normalizer by passing `normalize_llm`. Ensure you have the necessary LLM and pybox configurations.

```python
from pathlib import Path
from langchain_openai import ChatOpenAI
from pybox import AsyncLocalPyBoxManager
from tablegpt.agent import create_tablegpt_graph
from tablegpt import DEFAULT_TABLEGPT_IPYKERNEL_PROFILE_DIR

llm = ChatOpenAI(openai_api_base="YOUR_VLLM_URL", openai_api_key="whatever", model_name="TableGPT2-7B")
normalize_llm = ChatOpenAI(openai_api_base="YOUR_VLLM_URL", openai_api_key="whatever", model_name="YOUR_VLLM_MODEL_NAME")
pybox_manager = AsyncLocalPyBoxManager(profile_dir=DEFAULT_TABLEGPT_IPYKERNEL_PROFILE_DIR)

agent = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager,
    normalize_llm=normalize_llm,
    session_id="some-session-id", # This is required when using file-reading
)
```

--------------------------------

### Create TableGPT Graph with Truncation

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Instantiate the TableGPT graph, passing the configured LLM truncation settings.

```python
agent = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager,
    llm_truncation_config=llm_truncation_config
)
```

--------------------------------

### Extract Text2SQL Database Files

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/realtabbench/README.md

Unzip the downloaded database files for the bird and spider datasets into their respective directories for Text2SQL evaluation.

```bash
unzip bird_dev_database.zip -d realtabbench/evalset/bird_data \
   && \
   unzip spider_dev_database.zip -d realtabbench/evalset/spider_data \
   && 
unzip spider_test_database.zip -d realtabbench/evalset/spider_data
```

--------------------------------

### Prepare HumanMessage with File Attachment

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/chat-on-tabular-data.ipynb

Construct a `HumanMessage` to include a file for the agent to process. The file is specified in `additional_kwargs` under the 'attachments' key. Ensure your iPython kernel can access the specified filename.

```python
from typing import TypedDict
from langchain_core.messages import HumanMessage

class Attachment(TypedDict):
    """Contains at least one dictionary with the key filename."""
    filename: str

attachment_msg = HumanMessage(
    content="",
    # Please make sure your iPython kernel can access your filename.
    additional_kwargs={"attachments": [Attachment(filename="titanic.csv")]},
)
```

--------------------------------

### Initialize ChatOpenAI with Max Tokens

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Configure the ChatOpenAI model with a specific maximum token limit for completions. This is crucial when the model service has a known maximum context length.

```python
llm = ChatOpenAI(openai_api_base="YOUR_VLLM_URL", openai_api_key="whatever", model_name="TableGPT2-7B",max_tokens=256)
```

--------------------------------

### Create TableGPT Graph Agent

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Instantiate the TableGPT graph agent, passing the configured language model and a pybox manager. This agent will be used for processing messages.

```python
agent_without_truncation = create_tablegpt_graph(
    llm=llm,
    pybox_manager=pybox_manager
)
```

--------------------------------

### Preview First 5 Rows of DataFrame

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/file-reading.ipynb

Displays the first 5 rows of the DataFrame to provide a quick look at the data's structure and content after transformation.

```python
df1.head(5)
```

--------------------------------

### Build Context-Aware Retriever

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/retrieval.ipynb

Enhance retrieval by using ContextualCompressionRetriever with ColumnDocCompressor to focus on relevant columns. This creates an efficient dataset retriever.

```python
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import DocumentCompressorPipeline
from tablegpt.retriever import ColumnDocCompressor

dataset_compressor = DocumentCompressorPipeline(
    transformers=[ColumnDocCompressor()]
)

dataset_retriever = ContextualCompressionRetriever(
    base_compressor=dataset_compressor,
    base_retriever=dataset_base_retriever,
)
```

--------------------------------

### Preview First 5 Rows of DataFrame (Content)

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/file-reading.ipynb

Shows the first 5 rows of the DataFrame to give a visual preview of the dataset's content, useful for identifying patterns or anomalies.

```python
# Show the first 5 rows to understand the structure
df1.head(5)
```

--------------------------------

### Import TruncationConfig

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Import the TruncationConfig class from the data_analyzer module.

```python
from tablegpt.agent.data_analyzer import TruncationConfig
```

--------------------------------

### Prepare Attachment Message for File Processing

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/normalize-datasets.ipynb

Construct a HumanMessage with the filename in `additional_kwargs` to specify the dataset file for the tablegpt-agent. Ensure the iPython kernel can access the specified file.

```python
from typing import TypedDict
from langchain_core.messages import HumanMessage

class Attachment(TypedDict):
    """Contains at least one dictionary with the key filename."""
    filename: str

attachment_msg = HumanMessage(
    content="",
    # Please make sure your iPython kernel can access your filename.
    additional_kwargs={"attachments": [Attachment(filename="产品生产统计表.xlsx")]},
)
```

--------------------------------

### Create Pie Chart

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/agent-workflow.md

This code generates a pie chart to visualize gender distribution. Ensure 'gender_counts' is defined before execution.

```python
plt.figure(figsize=(6, 6))
plt.pie(gender_counts, labels=gender_counts.index, autopct='%1.1f%%', startangle=140)
plt.title('Gender Distribution')
plt.show()
```

--------------------------------

### Enable Async Console

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/quick-start.ipynb

Ensure your Python console supports asynchronous operations by running this command if you are not in a Jupyter Notebook.

```bash
python -m asyncio
```

--------------------------------

### Invoke Agent and Handle Errors

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/messages-truncation.ipynb

Prepare the input for the agent, including the message history and a parent ID. Invoke the agent asynchronously and catch potential exceptions, such as 'BadRequestError' which indicates the message length exceeded the model's context limit.

```python
_input = {
    "messages": messages,
    "parent_id": "some-parent-id",
    "date": date.today(),  # noqa: DTZ011
}

try:
    await agent_without_truncation.ainvoke(input=_input)
except Exception as e:
    print(e)
```

--------------------------------

### Upload and Inspect CSV Data

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/chat-on-tabular-data.ipynb

Upload a CSV file and use an agent to read it into a pandas DataFrame. Inspect the DataFrame's info and head to understand its structure and content.

```python
response = await agent.ainvoke(
    input={
        "entry_message": attachment_msg,
        "processing_stage": Stage.UPLOADED,
        "messages": [attachment_msg],
        "parent_id": "some-parent-id1",
        "date": date.today(),
    },
    config={
        # Using checkpointer requires binding thread_id at runtime.
        "configurable": {"thread_id": "some-thread-id"},
    },
)
response["messages"]
```

```python
# Load the data into a DataFrame
df = read_df('titanic.csv')

# Remove leading and trailing whitespaces in column names
df.columns = df.columns.str.strip()

# Remove rows and columns that contain only empty values
df = df.dropna(how='all').dropna(axis=1, how='all')

# Get the basic information of the dataset
df.info(memory_usage=False)
```

```python
# Show the first 5 rows to understand the structure
df.head(5)
```

--------------------------------

### Run Local Code Quality Checks

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/CONTRIBUTING.md

Execute linting and testing commands locally to ensure code quality before submitting a pull request. This mirrors the checks performed by GitHub Actions.

```shell
make lint && make test
```

--------------------------------

### Run Text2SQL Evaluation Script

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/realtabbench/README.md

Execute the evaluation script for Text2SQL, specifying the model path, evaluation dataset name (bird or spider), and mode (dev or test).

```bash
python run_text2sql_eval.py --model_path <MODEL_PATH> \
   --eval_data_name <enum ["bird", "spider"]> \
   --mode <enum ["dev", "test"]>
```

--------------------------------

### Continue Conversation with TableGPT

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/persist-messages.ipynb

Continue an existing conversation by providing new input and the same `config` used previously. This allows the agent to maintain context from prior interactions.

```python
resp = await graph.ainvoke(
    input={
        "messages": [("human", "Please name three movies he participated in.")],
        "parent_id": "1",
        "date": date.today(),
    },
    config={\"configurable\": {\"thread_id\": \"1\"}},
)
resp["messages"][-1]
```

--------------------------------

### Run TableGPT Agent Evaluation

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/realtabbench/agent_eval/README.md

Executes the TableGPT agent evaluation script. Ensure environment variables are set or a .env file is present in the root directory.

```sh
python -m agent_eval --config path/to/your/config.yaml
```

--------------------------------

### Enable Visual Analysis with VLM

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/explanation/agent-workflow.md

To enable visual analysis, pass a VLM model instance to the 'create_tablegpt_graph' function. This allows the agent to generate visual representations of data.

```python
from langchain_openai import ChatOpenAI
from tablegpt.agent import create_tablegpt_graph

vlm = ChatOpenAI(openai_api_base="VLM_URL", openai_api_key="whatever", model_name="VLM_MODEL_NAME")

agent = create_tablegpt_graph(
    ...
    vlm=vlm,
    ...
)
```

--------------------------------

### Retrieve and Replay State History

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/continue-analysis-on-generated-charts.ipynb

Fetches the state history of an agent and identifies the last state where the next action was '__start__'. This is used for time travel to replay agent actions from a specific historical point.

```python
state_history = agent.get_state_history(config={"configurable": {"thread_id": "some-thread-id"}})

to_replay = None
for state in list(state_history)[::-1]:
    if state.next and state.next[0] == "__start__":
        to_replay = state
```

--------------------------------

### Display First 5 Rows of DataFrame

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/howto/normalize-datasets.ipynb

Displays the first 5 rows of the DataFrame to help understand its structure after processing.

```python
# Show the first 5 rows to understand the structure
df.head(5)
```

--------------------------------

### Stream Agent Events for Visualization Analysis

Source: https://github.com/tablegpt/tablegpt-agent/blob/main/docs/tutorials/continue-analysis-on-generated-charts.ipynb

Initiate a streaming analysis of agent events to generate a pie chart based on gender data. This method allows for real-time observation of the agent's processing, including tool usage and message outputs.

```python
# Define the human message that asks the model to draw a pie chart based on gender data
human_message = HumanMessage(content="Draw a pie chart based on gender and the number of people of each gender.")

async for event in agent.astream_events(
    input={
        "messages": [human_message],
        "parent_id": "some-parent-id2",
        "date": date.today(),
    },
    version="v2",
    # We configure the same thread_id to use checkpoints to retrieve the memory of the last run.
    config={"configurable": {"thread_id": "some-thread-id"}},
):
    evt = event["event"]
    if evt == "on_chat_model_end":
        print(event["data"]["output"])
    elif event["name"] == "tool_node" and evt == "on_chain_stream":
        for lc_msg in event["data"]["chunk"]["messages"]:
            print(lc_msg)
    else:
        # Handle other events here
        pass
```
Tokens:
Raw