Refactor workshop documentation by removing outdated examples

- Eliminated outdated example sections from chapter3-2.md and chapter3-3.md to enhance clarity and focus on relevant content.
- Streamlined the documentation to improve user engagement and understanding of streaming and interactive features.

Author: jxnl

docs/workshops/chapter3-2.md

@@ -181,10 +181,7 @@ async def stream_query_response(request: Request):
 
 On the frontend, you'll need to handle Server-Sent Events (SSE) or WebSockets to receive and display the streamed content:
 
-!!! example "Frontend Streaming Implementation"
-```
-*This code shows how to handle streaming responses on the frontend, creating a reader for the response stream, decoding chunks as they arrive, and updating the UI in real-time to display incremental results.*
-```
+
 
 ### Showing Function Call Arguments
 
@@ -259,10 +256,7 @@ async def stream_structured_response(query: str):
 
 On the frontend, you'd handle this structured stream by updating different UI components based on the message type:
 
-!!! example "Structured Data Streaming Handler"
-```
-*This code processes a structured data stream, separating different components (answer chunks, citations, follow-up questions) and rendering each in their appropriate UI sections. This creates a dynamic, engaging experience where different parts of the response appear progressively.*
-```
+
 
 This approach creates a dynamic, engaging experience where different parts of the response appear progressively, keeping users engaged throughout the generation process.
 
@@ -374,10 +368,7 @@ async def generate_interstitials(query: str):
 
 On the frontend, you'd display these interstitials in sequence during the waiting period:
 
-!!! example "Meaningful Interstitials Implementation"
-```
-*This code shows how to fetch and display domain-specific interstitial messages that rotate every few seconds. The animation and context-specific messages engage users during waiting time, making the system feel more responsive.*
-```
+
 
 ## Optimizing Actual Performance
 
@@ -441,10 +432,7 @@ Here's a simple but effective approach for Slack bots:
 
 1. **Feedback Collection**: Pre-fill emoji reactions (👍 👎 ⭐) to prompt users for feedback on the response quality.
 
-!!! example "Slack Bot Pseudo-Streaming Implementation"
-```
-*This code shows how to implement pseudo-streaming in a Slack bot environment, using message updates, emoji reactions, and staged processing to create the illusion of progress and maintain user engagement.*
-```
+
 
 !!! tip "Slack Feedback Collection"
 By pre-filling emoji reactions (👍 👎 ⭐), you increase the likelihood of receiving user feedback. This approach places feedback options directly in the user's view, rather than requiring them to take additional steps. In testing, this approach increased feedback collection rates by up to 5x compared to text-based feedback prompts.

docs/workshops/chapter3-3.md

@@ -120,10 +120,7 @@ def create_citation_prompt(query: str, documents: list):
 
 On the frontend, you can turn these citations into interactive elements:
 
-!!! example "Interactive Citations Rendering"
-```
-*This code turns a response with citation markers into an interactive UI where citations are clickable elements, and sources can be rated for relevance.*
-```
+
 
 This creates an interactive experience where citations are visually distinct, clickable elements. When users engage with these elements, you can collect valuable feedback while enhancing their understanding of the response.
 
@@ -239,10 +236,7 @@ def chain_of_thought_prompt(query: str, documents: list):
 
 Taking this a step further, you can stream the thinking process as a separate UI component or interstitial. This serves two purposes: it makes the waiting time more engaging by showing users that complex reasoning is happening, and it allows users to intervene if they notice the reasoning going astray.
 
-!!! example "Chain of Thought Streaming Implementation"
-```
-*This code processes streamed tokens containing XML-tagged thinking and answer sections, rendering them in separate UI components. This makes the reasoning process transparent and engaging for users.*
-```
+
 
 A financial advisory firm implemented this approach for their investment recommendation system. As the model reasoned through market conditions, client preferences, and portfolio considerations, this thinking was streamed to the advisor in a separate panel. If the advisor noticed a misunderstanding, they could pause generation and refine their query before the final recommendation.