Practical Guide to Developing an Intelligent Document Assistant with Streamlit and DeepSeek

✨Hello, I am Xiaoke, welcome to the “Xiaoke AI Study Group”

Today’s article theme is:

Practical Development of an Intelligent Document Assistant Based on Streamlit and DeepSeekHere is a demonstration of the practical effects:

Practical Guide to Developing an Intelligent Document Assistant with Streamlit and DeepSeek

In this article, you will gain:

Basic interactive interface for large models
Basic logic design for large model interaction
Reading PDF files
Loading environment variables
Practical explanation of large model applications in intelligent documents

🚀 Keyword Tags: AI Practical Developers | Technical Growth Companions | RAG Frontier Explorers

🌈 Looking forward to collaborating with you: Become a partner in “AI + Growth”! Here you will gain:

✅ Weekly updated AI development notes
✅ Reusable code example library
✅ Dissection of cutting-edge technology application scenarios
✅ Exclusive growth methods for students
✅ Regular in-depth reading of good books

Technical Preview: In the next issue, we will introduce RAG (Retrieval-Augmented Generation) technology to achieve:✅ Semantic document chunking✅ Vector database retrieval✅ Better dynamic context management

Table of Contents
Preface: Voices from Readers
1. Development Environment Preparation

1.1 Install Dependency Libraries
1.2 Environment Configuration
1.3 Run and Experience

2. Core Function Breakdown
3. Key Code Analysis

3.1 Document Processing Module
3.2 Stream Response Implementation
3.3 CRISPE Prompt Engineering
3.4 Streamlit Frontend Button Settings
3.5 File Upload Component
3.6 Chat History Display
3.7 Dialogue Logic Control

4. DeepSeek Intelligent Document Assistant Introduction Guide

Project Overview
Basics of Streamlit Framework
Project Logic Design Breakdown

5. Limitations of the Current Version
6. Summary
Appendix – Code Documentation

DeepSeek Intelligent Document Assistant Application Documentation

Preface: Voices from Readers

Yesterday I received feedback from readers: “AI development tutorials are not satisfying enough when only theory is discussed. Can we go through the development process with real code?” Today we will useStreamlit as a small frontend, combined withDeepSeek large model, to guide everyone in developing an intelligent assistant capable of document analysis step by step. The code in this article has been tested (for the complete source code, see the appendix at the end). It is recommended to read while practicing.

Project open-source address:

https://github.com/li-xiu-qi/XiaokeAILabs.git

1. Development Environment Preparation

1.1 Install Dependency Libraries

# Core dependencies
pip install streamlit pymupdf python-dotenv openai

1.2 Environment Configuration

Create a.env file in the project root directory:

Note, the api-key comes from Silicon Flow, and you need to obtain the api-key at the following address: https://cloud.siliconflow.cn/account/ak

API_KEY=your_silicon_api_key

1.3 Run and Experience

streamlit run xiaoke_doc_assist.py

After starting, you will see:

Select the model and parameters on the left panel
Upload documents and chat on the main interface

2. Core Function Breakdown

The intelligent assistant we designed needs to achieve:

📁 Multi-format document parsing (TXT/PDF)
🤖 Dynamic switching of various large models
🎚️ Adjust temperature/context length
💬 Dialogue system with historical memory

3. Key Code Analysis

3.1 Document Processing Module

def process_uploaded_file():
    # Multi-format processing logic
    if PDF:  # PyMuPDF parsing
        with fitz.open() as doc:
            text += page.get_text()
    else:    # Decode text directly
        content = file.getvalue().decode()
    # Smartly capture the first N characters
    return content[:context_length] + "..."

3.2 Stream Response Implementation

with st.chat_message("assistant"):
    response_placeholder = st.empty()
    collected_response = []
    
    # Real-time get response segments
    for chunk in response:
        if chunk.choices[0].delta.content:
            token = chunk.choices[0].delta.content
            collected_response.append(token)
            response_placeholder.markdown("".join(collected_response) + "▌")  # Typing effect

3.3 CRISPE Prompt Engineering

&lt;system&gt;

    [Current Date] {CURRENT_DATE}

    [Role] You are a professional document analysis assistant, skilled at extracting key information from technical documents.

    [Background]

    - The user has uploaded the document: {uploaded_file.name}

    - Document type: {uploaded_file.type.split('/')[-1].upper()}

    - Document content: {processed_content[:st.session_state.file_content_length]}...

    [Core Tasks]

    1. When the user asks a question, prioritize finding the answer from the document.

    2. Think step by step for complex questions.

    3. Do not generate information not provided by the document.

    4. Maintain a professional and understandable tone.

    5. When uncertain, request the user to provide more information.

    [Interaction Requirements]

    - Maintain a professional and understandable tone.

    - Key data should be displayed in **bold**.

    - Code blocks should be wrapped in ```.

&lt;/system&gt;

3.4 Streamlit Frontend Button Settings

  # Sidebar settings  
with st.sidebar:  
    st.header("Configuration Parameters")  
    selected_model = st.selectbox(  
        "Select Model",  
        options=list(model_list.keys()),  
        index=2  
    )  
    temperature = st.slider("Temperature Parameter", 0.0, 1.0, 0.3, 0.1)  
    max_tokens = st.slider("Maximum Length", 100, 4096, 2048, 100)  
    st.session_state.context_length = st.slider("Context Length", 1000, 100000, 18000, 500)  
    st.session_state.file_content_length = st.slider("File Content Read Length", 1000,100000, 15000, 500)  
      
    # New conversation button  
    if st.button("New Conversation"):  
        st.session_state.messages = []  
        st.session_state.uploaded_content = None  
        st.session_state.current_file = None  
        st.success("New conversation created!")  
  
st.title("📑 DeepSeek Intelligent Document Assistant ✨")

3.5 File Upload Component

# File upload component
uploaded_file = st.file_uploader("Upload Document (supports PDF/TXT)", type=["pdf", "txt"])

if uploaded_file and uploaded_file != st.session_state.get("current_file"):

    processed_content = process_uploaded_file(uploaded_file)

    if processed_content:

        st.session_state.uploaded_content = processed_content

        st.session_state.current_file = uploaded_file

        # Build CRISPE framework system prompt

        system_prompt = f"""

&lt;system&gt;

    [Current Date] {CURRENT_DATE}

    [Role] You are a professional document analysis assistant, skilled at extracting key information from technical documents.

    [Background]

    - The user has uploaded the document: {uploaded_file.name}

    - Document type: {uploaded_file.type.split('/')[-1].upper()}

    - Document content: {processed_content[:st.session_state.file_content_length]}...

    [Core Tasks]

    1. When the user asks a question, prioritize finding the answer from the document.

    2. Think step by step for complex questions.

    3. Do not generate information not provided by the document.

    4. Maintain a professional and understandable tone.

    5. When uncertain, request the user to provide more information.

    [Interaction Requirements]

    - Maintain a professional and understandable tone.

    - Key data should be displayed in **bold**.

    - Code blocks should be wrapped in ```.

&lt;/system&gt;

        """

        # Clear history messages

        st.session_state.messages = [{"role": "system", "content": system_prompt}]

        st.success(f"Document {uploaded_file.name} parsed successfully!")

else:

    # Default system prompt template

    default_system_prompt = f"""

    &lt;system&gt;

        [Current Date] {CURRENT_DATE}

        [Role] You are a professional document analysis assistant.

        [Core Tasks]

        1. When the user asks a question, you can ask the user if they need to provide materials to enhance the answer.

        2. Think step by step for complex questions.

        3. Do not generate information not provided by the document.

        4. Maintain a professional and understandable tone.

        5. When uncertain, request the user to provide more information.

        [Interaction Requirements]

        - Maintain a professional and understandable tone.

        - Key data should be displayed in **bold**.

        - Code blocks should be wrapped in ```.

    &lt;/system&gt;

    """

    if not st.session_state.messages:

        st.session_state.messages = [

            {"role": "system", "content": default_system_prompt}

        ]

3.6 Chat History Display

# Chat history display
for msg in st.session_state.messages:

    if msg["role"] != "system":

        with st.chat_message(msg["role"]):

            st.markdown(msg["content"])

3.7 Dialogue Logic Control

# User input processing
if prompt := st.chat_input("Please enter your question..."):

    # Add user message

    st.session_state.messages.append({"role": "user", "content": prompt})

    with st.chat_message("user"):

        st.markdown(prompt)
  
    # Build API request

    keep_messages = 10

    system_message = st.session_state.messages[0]  # Keep the first system message

    messages_for_api = [

        {"role": m["role"], "content": m["content"]}

        for m in st.session_state.messages

        if m["role"] != "system"

    ]
  
    # Truncate context to meet context length requirements

    total_length = sum(len(m["content"]) for m in messages_for_api)

    while total_length &gt; st.session_state.context_length:

        messages_for_api.pop(0)

        total_length = sum(len(m["content"]) for m in messages_for_api)
  
    messages_for_api.insert(0, system_message)  # Reinsert the system message to the first
  
    try:

        # Generate streaming reply

        with st.chat_message("assistant"):

            response_placeholder = st.empty()

            collected_response = []
  
            response = client.chat.completions.create(

                model=model_list[selected_model],

                messages=messages_for_api,

                stream=True,

                temperature=temperature,

                max_tokens=max_tokens,

            )
  
            for chunk in response:

                if chunk.choices[0].delta.content:

                    token = chunk.choices[0].delta.content

                    collected_response.append(token)

                    response_placeholder.markdown("".join(collected_response) + "▌")

            final_response = "".join(collected_response)

            response_placeholder.markdown(final_response)
  
            # Update message records

            st.session_state.messages.append(

                {"role": "assistant", "content": final_response}

            )

4. DeepSeek Intelligent Document Assistant Introduction Guide

Project Overview

This project is an intelligent document analysis assistant built on the Streamlit framework. It leverages DeepSeek’s large language model (LLM) to understand and analyze user-uploaded documents and provide answers based on user questions. The main features include:

Document Upload and Parsing: Supports uploading PDF and TXT documents, extracting document content.
Intelligent Q&A: Users can ask questions about the uploaded document content, and the assistant will try to find answers from the document.
Model Selection and Parameter Adjustment: Users can select different DeepSeek models from the sidebar and adjust parameters such as temperature and maximum length.
Dialogue Management: Supports creating new conversations (clearing historical dialogue records).

Basics of Streamlit Framework

Streamlit is a Python library for quickly building interactive web applications, especially suitable for machine learning and data science projects. Its core philosophy is to “empower data scientists to easily create beautiful and powerful applications”.

In this project, Streamlit is mainly responsible for building the user interface (UI), including:

Sidebar: Used to place configuration parameters, such as model selection, temperature, maximum length, etc. Created using with st.sidebar: code block.
File Uploader: Allows users to upload documents. Created using st.file_uploader().
Chat Input: The place where users input questions. Created using st.chat_input().
Chat Message Display: Displays the history of conversations between the user and the assistant. Created using st.chat_message() and st.markdown() combined.
Session State: An important feature of Streamlit, used to persist data between different stages of user interaction with the application. For example, dialogue message history, uploaded document content, etc., are all stored in st.session_state.

Project Logic Design Breakdown

To better understand the code, we will break its logic down into several key modules and explain them in conjunction with the previously generated flowchart.

1. Initialization (init_session Function)

Function: The init_session() function is responsible for initializing the session_state of the Streamlit application. Ensures that the application has the required state variables at startup.
Process:

messages: A list that stores the history of dialogue messages, initially an empty list [].
uploaded_content: Stores the content of the uploaded document, initially set to None.
context_length: Sets the model context length, initially set to 30000.
file_content_length: Sets the length of the content read from the file, initially set to 15000.

Check if st.session_state already contains the keys messages, uploaded_content, context_length, and file_content_length.
If they do not exist, initialize them:

Purpose: To ensure that the session state variables required for the application to run are correctly initialized, avoiding errors during subsequent use.

2. Sidebar Configuration (with st.sidebar Code Block)

Function: The with st.sidebar: code block defines the content of the application sidebar, used for user configuration parameters.
Process:

Use st.header("Configuration Parameters") to add a title to the sidebar.
Use st.selectbox("Select Model", ...) to create a model selection dropdown, allowing users to choose a model from model_list.
Use st.slider("Temperature Parameter", ...) to create a temperature parameter slider for adjusting the randomness of the model’s generated responses.
Use st.slider("Maximum Length", ...) to create a maximum length slider that limits the maximum number of tokens generated by the model.
Use st.slider("Context Length", ...) to create a context length slider that allows users to adjust the context length of the uploaded document.
Use st.slider("File Content Read Length", ...) to create a file content read length slider that allows users to adjust the maximum length of the content read from the file.
Use st.button("New Conversation") to create a “New Conversation” button that clears the historical dialogue and uploaded document when clicked.

Purpose: To provide a user-friendly interface that allows users to configure models and parameters according to their needs.

3. File Upload and Processing

Function: To process the document uploaded by the user and extract text content.
Process:

Update st.session_state.uploaded_content with the processed document content.
Update st.session_state.current_file with the current uploaded file object to determine if the file has changed.
Build a system prompt (System Prompt), which is a key step in guiding the LLM on how to play a role, understand the background, execute tasks, and interact. The system prompt uses the CRISPE framework, including role, background, core tasks, and interaction requirements, and dynamically injects the uploaded file name, file type, and part of the document content into the prompt.
Add the system prompt as the first message to the st.session_state.messages list.
Use st.success() to display a message indicating that document parsing was successful.

process_uploaded_file function internal logic:

Determine whether the file type (uploaded_file.type) is PDF or TXT.
If it is PDF, use the fitz library (PyMuPDF) to open the PDF file and extract text content page by page.
If it is TXT, directly read the file content and decode it as a UTF-8 string.
Based on st.session_state.file_content_length, capture the first N characters of the document content and add “…” to indicate truncation.
If an exception occurs during processing, use st.error() to display an error message.

Use st.file_uploader("Upload Document...", type=["pdf", "txt"]) to create a file upload component that allows users to upload PDF or TXT files.
When the user uploads a file, the code checks whether a new file has been uploaded and whether the uploaded file is different from the one recorded in the current session_state.
Call the process_uploaded_file(uploaded_file) function to process the uploaded file:
If file processing is successful (processed_content is not None):
Finally, the st.session_state.messages = [{"role": "system", "content": system_prompt}] part will clear the historical dialogue, reducing noise interference. If you want to optimize the user experience, you can choose to insert and replace the form to change the template; we choose the former here.

Purpose: To receive documents uploaded by users, extract text content that can be used for analysis, and dynamically generate system prompts based on the uploaded documents to prepare for the subsequent intelligent Q&A phase.

4. Chat Message Processing (User Input and Assistant Response)

Function: To process user chat input, call the DeepSeek API to obtain model responses, and display dialogue messages.
Process:

Add the user’s input message to the st.session_state.messages list, with the role set to “user”.
Use st.chat_message("user"): st.markdown(prompt) to display the user message in the chat interface.
Build the API request message list messages_for_api. To control the context length, the code only takes the last 10 messages (excluding system messages, only user messages and assistant messages) as the context for the API request.
Call the DeepSeek API’s client.chat.completions.create(...) method to send the API request and obtain streaming responses:
Process API Streaming Responses:
Handle API Errors: Use try...except openai.APIError as e: to catch errors that may occur during API requests (e.g., context too long). If an openai.APIError occurs:

model: Use the model selected by the user in the sidebar (model_list[selected_model]).
messages: Use the constructed messages_for_api message list as context.
stream=True: Enable streaming response mode, where the model returns results token by token rather than all at once.
temperature: Use the temperature parameter set by the user in the sidebar.
max_tokens: Use the maximum length parameter set by the user in the sidebar.
file_content_length: Use the maximum read file length set by the user in the sidebar.

For each chunk (data block), extract the token content from chunk.choices[0].delta.content.
Add the token to the collected_response list.
Use response_placeholder.markdown("".join(collected_response) + "▌") to dynamically update the content of the assistant message container, displaying the received tokens and adding the “▌” symbol at the end to indicate streaming output.

Use with st.chat_message("assistant"): response_placeholder = st.empty() to create an assistant message container response_placeholder, used to dynamically display streaming responses.
Initialize an empty list collected_response, used to store the tokens received.
Iterate over the streaming response returned by the API:
Assign the complete response content "".join(collected_response) to final_response.
Use response_placeholder.markdown(final_response) to finally display the complete assistant response.
Add the assistant response message to the st.session_state.messages list, with the role set to “assistant”.

Build an error message containing error analysis and correction suggestions error_msg.
Use st.error(error_msg, icon="🚨") to display error information on the interface.

Display Chat History: Iterate over the st.session_state.messages list, displaying each message in the chat interface. System messages (role == "system") are not displayed. User messages (role == "user") and assistant messages (role == "assistant") are displayed using st.chat_message("user") and st.chat_message("assistant"), respectively, and the message content is rendered using st.markdown().
Receive User Input: Use prompt = st.chat_input("Please enter your question...") to create a chat input box, where the user’s input will be assigned to the prompt variable after pressing the enter key.
Process User Input:

Purpose: To achieve dialogue interaction between the user and the intelligent assistant, sending user questions to the DeepSeek model for intelligent replies, and displaying the dialogue process and results in real-time in the chat interface. At the same time, handle potential API errors and provide friendly error prompts.

5. New Conversation Button

Function: Clicking the “New Conversation” button clears the current dialogue history and uploaded documents, starting a new conversation.
Process (Reference):

Clear the st.session_state.messages list, deleting all dialogue messages.
Set st.session_state.uploaded_content to None, clearing the uploaded document content.
Set st.session_state.current_file to None, clearing the current file record.
Use st.success("New conversation created!") to display a success message.

Use st.button("New Conversation") to create a button.
When the button is clicked:

Purpose: To provide users with a convenient way to start a new conversation, clearing old dialogue context and document information to avoid interference with new dialogues.

6. Code Structure and Process Summary

Initialization Phase: The init_session() function initializes the necessary session_state variables when the application starts.
Sidebar Configuration: The with st.sidebar: code block sets various configuration components in the sidebar, allowing users to customize models and parameters.
Document Upload Phase: Users upload documents through st.file_uploader, the process_uploaded_file function processes the document content and dynamically generates system prompts.
Dialogue Interaction Phase: Users input questions in st.chat_input, and the application sends the questions and historical dialogue records to the DeepSeek API to obtain streaming responses and display them in st.chat_message.
Session State Management: The st.session_state runs throughout the application’s lifecycle, storing and maintaining important data such as dialogue history and uploaded document content, allowing the application to remember the user’s context information and achieve continuous historical dialogue.
Error Handling: The code includes the capture and handling of file processing exceptions and API request errors, improving the robustness of the application.

Advice for Beginners

Learn Streamlit Step by Step: The learning curve for Streamlit is relatively gentle, and you can start with the official documentation and examples to gradually master various components and functions.
Understand the Importance of Session State: Session State is key to building interactive Streamlit applications, and understanding how it works and how to use it is essential.
Focus on Prompt Engineering: The design of system prompts is crucial for the effectiveness of LLM applications. You can learn Prompt Engineering techniques such as the CRISPE framework to continuously optimize prompts and improve model performance.
Practice and Experiment: Modify code, adjust parameters, and try different documents and questions to deepen your understanding of code logic and LLM applications.
Refer to Documentation and Community: When encountering problems, refer to the official documentation related to Streamlit and OpenAI, or seek help in the community. You are welcome to ask me questions; I will do my best to answer them, and I am glad to have partners learning together with us.

5. Limitations of the Current Version

Although the basic functions have been implemented, there are still the following points to optimize:

Context Truncation: Simply taking the first N characters may lose key information.
File Processing: High memory consumption when loading large files, and extraction effects are poor.
History Management: Fixed round memory windows are not intelligent enough.

6. Summary

Through the practical development in this article, we have completed:

✅ Basic layout construction of Streamlit✅ DeepSeek API integration✅ Prototype development of document dialogue system

Challenge Yourself: Try changing the file_content_length parameter value to 30000, and observe the impact on long file processing. Share your findings in the comments!

Readers who need the complete source code are welcome to reply “Intelligent Document Assistant” in the public account backend to obtain the GitHub repository address and source code. In the next issue, we will bring advanced modifications of RAG technology, so stay tuned!

🗺️ Content Map ──────

✨ If this content has inspired you, feel free to:

✅ Click “Looking” to let more partners see it.

🔄 Forward to share with those who need it.

⭐ Light up the star mark, so you won’t miss updates.

💬 Interaction Field ──────

🎙️ The comment section is waiting for you to chat:

1️⃣ Lightning Harvest: What struck you the most at this moment? What was your biggest gain after reading?

2️⃣ Action Code: The first action you want to try tomorrow, how do you plan to act next?

3️⃣ Content Co-creation: The theme of the next issue is lit by you. What other themes do you want me to write about?

⚡ Energy Circuit ──────

📮 Every message is an inspiration wave.

💌 I will carefully read every message. Your support is the motivation for my continuous creation! See you in the next article~

❤️🔥 Your interaction is powering the creative universe (System prompt: The next strategy is being generated…)

🙋♂️ Join the group for communication & material collection

1️⃣ Joining Method

Click “Community” in the public account menu, scan the code to join the group directly.
Reply with keywords “Join Group” or “Add Group”, and add the author’s WeChat for manual invitation.

2️⃣ Material Collection

After joining the group, check the group announcement to obtain learning resources.
Reply “Material” to the public account to automatically send the cloud disk link (updated regularly).
Click “Material Collection” in the public account menu.

Appendix – Code Documentation

DeepSeek Intelligent Document Assistant Application Documentation

Application Overview

This application is an intelligent dialogue assistant based on the DeepSeek large model, supporting the following core functions:

✅ Multi-model selection (providing 3 models of different scales)
✅ Document analysis mode (supporting TXT/PDF file parsing)
✅ Adjustable dialogue parameters (temperature, context length)
✅ Real-time streaming response
✅ Dialogue history management

Function Features

1. Multi-model Support

Model Name	Applicable Scenarios
DeepSeek-R1-1.5B	Free and fast response to basic Q&A
DeepSeek-V3	General scenario dialogue
DeepSeek-R1	Complex reasoning and long text understanding

2. Document Analysis Mode

Supported formats: TXT/PDF
Processing flow:

Automatically parse uploaded files
Extract the first 15k characters as document content input (configurable)
Retain the last 32k characters of context (configurable)
Automatically switch between document/ordinary mode

3. Parameter Configuration

Temperature (0.001-1.2): Controls the randomness of generation
Context Length (100-30k tokens): Manages the length of dialogue history
Maximum Output Length (fixed at 8192 tokens)

Usage Guide

Environment Requirements

Python 3.10+
Dependency libraries: streamlit, pymupdf, python-dotenv, openai

Install Dependencies

pip install streamlit PyMuPDF python-dotenv openai

Running Steps

Configure environment variables

API_KEY=your_deepseek_api_key

Start the application

streamlit run xiaoke_doc_assist.py

Interface Operation

Model Selection Area (Left)

Dropdown to select model version
Slider to adjust temperature value
Set context length
Control the length of document content read

Document Upload Area

Supports drag-and-drop uploads
Automatically recognize file types
Shows green prompt after successful loading

Dialogue Interface

User input box is at the bottom
Real-time display of dialogue history
Assistant responses with typing effect

Key Modules

File Processing (process_uploaded_file)

TXT files: Directly read UTF-8 encoding
PDF files: Use PyMuPDF to parse text
Content capture: Retain the first N characters (N=context_length)

Message Management

Add document content when the file is updated

Retain the last 10 messages (5 rounds of dialogue)
System message processing rules:

API Call

response = client.chat.completions.create(
    model=model_list[selected_model],
    messages=messages_for_api,  # Complete context including system prompt
    stream=True,                  # Enable streaming
    temperature=temperature,
    max_tokens=8192              # Fixed maximum output length
)

Precautions

The API key must be configured through the .env file
PDF parsing depends on embedded fonts, which may affect format restoration
Context length settings must consider the maximum length supported by the model
Temperature settings below 0.3 may produce deterministic responses
The file upload size is limited by Streamlit’s default limit (200MB)

Error Handling Mechanism

File parsing exceptions: Display red error prompts
API call failures: Roll back the recent message records
Streaming interruptions: Retain received content
Type errors: Automatically filter invalid message types

Interaction Optimization

Use streaming responses
Manage sliding context windows
File content preprocessor
Dialogue caching strategy (retain the last 5 rounds)

Performance Optimization Suggestions

Single dialogue context should be ≤16000 characters
PDF file page count should be ≤50 pages
For complex questions, it’s recommended to split them into multi-step inquiries

PS: Question: If it were you, how would you implement the code logic for this practical project? Do you think there is a better implementation plan?

Tip: Before sending this article, I showed it to friends in the community; some said the article was too long, while others said they couldn’t understand it. I tried to control the length. This article mainly covers these points; I will come back later with an article about the libraries used in this project, and I will also cover some basic knowledge about large model applications, such as the effects of some control parameters, etc.

Table of Contents