test(examples): Add some examples leveraging pydantic-AI and other chatlas alternatives

pkg-py/tests/playwright/chat/langchain/basic/app.py

@@ -0,0 +1,34 @@
+import os
+
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from shiny.express import ui
+
+_ = load_dotenv()
+chat_client = ChatOpenAI(
+    api_key=os.environ.get("OPENAI_API_KEY"),
+    model="gpt-4o",
+)
+
+ui.page_opts(
+    title="Hello LangChain Chat Models",
+    fillable=True,
+    fillable_mobile=True,
+)
+
+chat = ui.Chat(
+    id="chat",
+    messages=["Hello! How can I help you today?"],
+)
+chat.ui()
+
+
+@chat.on_user_submit
+async def handle_user_input(user_input: str):
+    response = chat_client.astream(user_input)
+
+    async def stream_wrapper():
+        async for item in response:
+            yield item.content
+
+    await chat.append_message_stream(stream_wrapper())

pkg-py/tests/playwright/chat/langchain/structured_output/app.py

@@ -0,0 +1,44 @@
+import os
+from typing import Optional
+
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
+from shiny.express import ui
+
+_ = load_dotenv()
+
+
+class Joke(BaseModel):
+    """Joke to tell user."""
+
+    setup: str = Field(description="The setup of the joke")
+    punchline: str = Field(description="The punchline to the joke")
+    rating: Optional[int] = Field(description="How funny the joke is, from 1 to 10")
+
+
+_ = Joke.model_rebuild()
+
+chat_client = ChatOpenAI(
+    api_key=os.environ.get("OPENAI_API_KEY"),
+    model="gpt-4o",
+)
+
+ui.page_opts(
+    title="Hello LangChain Chat Model using structured output",
+    fillable=True,
+    fillable_mobile=True,
+)
+
+chat = ui.Chat(
+    id="chat",
+    messages=["Hello! How can I help you today?"],
+)
+chat.ui()
+
+
+@chat.on_user_submit
+async def handle_user_input(user_input: str):
+    joke = chat_client.with_structured_output(Joke).invoke(user_input)
+    joke_text = f"{joke.setup}\n\n{joke.punchline}\n\nRating: {joke.rating if joke.rating is not None else 'N/A'}"
+    await chat.append_message_stream(joke_text)

pkg-py/tests/playwright/chat/langchain/tool_calling/app.py

@@ -0,0 +1,87 @@
+import os
+from datetime import datetime
+
+from dotenv import load_dotenv
+from langchain_core.messages import HumanMessage
+from langchain_core.tools import tool
+from langchain_openai import ChatOpenAI
+from shiny.express import ui
+
+_ = load_dotenv()
+
+
+@tool
+def get_current_time() -> str:
+    """Get the current time in HH:MM:SS format."""
+    return datetime.now().strftime("%H:%M:%S")
+
+
+@tool
+def get_current_date() -> str:
+    """Get the current date in YYYY-MM-DD format."""
+    return datetime.now().strftime("%Y-%m-%d")
+
+
+@tool
+def get_current_datetime() -> str:
+    """Get the current date and time in a readable format."""
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+tools = [get_current_time, get_current_date, get_current_datetime]
+
+tool_registry = {tool.name: tool for tool in tools}
+
+chat_client = ChatOpenAI(
+    api_key=os.environ.get("OPENAI_API_KEY"),
+    model="gpt-4o",
+).bind_tools(tools)
+
+ui.page_opts(
+    title="Hello LangChain Chat Models with Tools",
+    fillable=True,
+    fillable_mobile=True,
+)
+
+chat = ui.Chat(
+    id="chat",
+    messages=[
+        "Hello! How can I help you today? I can tell you the current time, date, or both!"
+    ],
+)
+chat.ui()
+
+
+@chat.on_user_submit
+async def handle_user_input(user_input: str):
+    messages = [HumanMessage(content=user_input)]
+
+    async def stream_response():
+        accumulated_tool_calls = []
+
+        async for chunk in chat_client.astream(messages):
+            tool_calls = getattr(chunk, "tool_calls", None)
+            if tool_calls:
+                accumulated_tool_calls.extend(tool_calls)
+
+            if chunk.content:
+                content = chunk.content
+                if isinstance(content, str):
+                    yield content
+                elif isinstance(content, list):
+                    for part in content:
+                        if isinstance(part, str):
+                            yield part
+
+        for tool_call in accumulated_tool_calls:
+            tool_name = tool_call.get("name", "")
+            if not tool_name:
+                continue
+
+            if tool_name in tool_registry:
+                result = tool_registry[tool_name].invoke({})
+                yield f"\n\n🔧 {tool_name}: {result}"
+            else:
+                yield f"\n\n❌ Unknown tool: {tool_name}"
+
+    await chat.append_message_stream(stream_response())

pkg-py/tests/playwright/chat/llama-index/basic/app.py

@@ -0,0 +1,46 @@
+from dotenv import load_dotenv
+from llama_index.core.llms import ChatMessage
+from llama_index.llms.openai import OpenAI
+from shiny.express import ui
+
+# Load environment variables from .env file
+_ = load_dotenv()
+
+llm = OpenAI(
+    model="gpt-4o-mini",
+)
+
+ui.page_opts(
+    title="Shiny Chat with LlamaIndex",
+    fillable=True,
+    fillable_mobile=True,
+)
+
+
+chat = ui.Chat(
+    id="chat",
+    messages=[
+        {"role": "system", "content": "You are a pirate with a colorful personality."},
+        {"role": "user", "content": "What is your name, pirate?"},
+        {
+            "role": "assistant",
+            "content": "Arrr, they call me Captain Cog, the chattiest pirate on the seven seas!",
+        },
+    ],
+)
+chat.ui()
+
+
+async def get_response_tokens(conversation: list[ChatMessage]):
+    response_stream = await llm.astream_chat(conversation)
+    async for r in response_stream:
+        yield r.delta
+
+
+@chat.on_user_submit
+async def handle_user_input():
+    conversation = [
+        ChatMessage(role=msg["role"], content=msg["content"]) for msg in chat.messages()
+    ]
+
+    await chat.append_message_stream(get_response_tokens(conversation))

pkg-py/tests/playwright/chat/llama-index/rag_with_chatlas/rag_example.py

@@ -0,0 +1,109 @@
+import os
+
+from chatlas import ChatOpenAI
+from llama_index.core import StorageContext, load_index_from_storage
+
+_ = os.environ.get("OPENAI_API_KEY")
+
+
+# Load the knowledge store (index) from disk
+try:
+    storage_context = StorageContext.from_defaults(persist_dir="./storage")
+    index = load_index_from_storage(storage_context)
+    print("LlamaIndex loaded successfully from ./storage")
+except Exception as e:
+    print(f"Error loading LlamaIndex: {e}")
+    print(
+        "Please ensure you have run the index creation script first if this is your initial run."
+    )
+    from llama_index.core import Document, VectorStoreIndex
+
+    print("Creating a dummy index for demonstration purposes...")
+    bookstore_documents = [
+        "Our shipping policy states that standard shipping takes 3-5 business days. Express shipping takes 1-2 business days. Free shipping is offered on all orders over $50.",
+        "Returns are accepted within 30 days of purchase, provided the book is in its original condition. To initiate a return, please visit our 'Returns' page on the website and fill out the form.",
+        "The 'BookWorm Rewards' program offers members 10% off all purchases and early access to sales. You earn 1 point for every $1 spent.",
+        "We accept Visa, Mastercard, American Express, and PayPal.",
+        "Currently, we do not offer international shipping outside of the United States and Canada.",
+        "The book 'The Midnight Library' by Matt Haig is a New York Times bestseller. It explores themes of regret and parallel lives.",
+        "Orders placed before 2 PM EST are processed on the same day.",
+    ]
+    documents = [Document(text=d) for d in bookstore_documents]
+    index = VectorStoreIndex.from_documents(documents)
+    index.storage_context.persist(persist_dir="./storage")
+    print("Dummy index created and saved.")
+
+
+def retrieve_trusted_content(
+    query: str, top_k: int = 3
+):
+    """
+    Retrieve relevant content from the bookstore's knowledge base.
+    This acts as the "lookup" for our customer service assistant.
+
+    Parameters
+    ----------
+    query
+        The customer's question used to semantically search the knowledge store.
+    top_k
+        The number of most relevant policy/book excerpts to retrieve.
+    """
+    retriever = index.as_retriever(similarity_top_k=top_k)
+    nodes = retriever.retrieve(query)
+    # Format the retrieved content clearly so Chatlas can use it as "trusted" information
+    return [f"<excerpt>{x.text}</excerpt>" for x in nodes]
+
+
+chat = ChatOpenAI(
+    system_prompt=(
+        "You are 'BookWorm Haven's Customer Service Assistant'. "
+        "Your primary goal is to help customers with their queries about shipping, returns, "
+        "payment methods, and book information based *only* on the provided trusted content. "
+        "If you cannot answer the question using the trusted content, politely state that "
+        "you don't have that information and suggest they visit the 'Help' section of the website."
+    ),
+    model="gpt-4o-mini",
+)
+
+# This is where Chatlas learns to "look up" information when needed.
+chat.register_tool(retrieve_trusted_content)
+
+
+# Example Customer Interactions with the Assistant
+print("\n--- BookWorm Haven Customer Service ---\n")
+
+# Example 1: Question that can be answered from the knowledge base (shipping policy)
+customer_query_1 = "How long does standard shipping take?"
+print(f"Customer: {customer_query_1}")
+response_1 = chat.chat(customer_query_1)
+print(f"Assistant: {response_1}\n")
+
+# Example 2: Another question answerable from the knowledge base (return policy)
+customer_query_2 = "What's your return policy?"
+print(f"Customer: {customer_query_2}")
+response_2 = chat.chat(customer_query_2)
+print(f"Assistant: {response_2}\n")
+
+# Example 3: Question about a specific book (information available)
+customer_query_3 = "Tell me about 'The Midnight Library'."
+print(f"Customer: {customer_query_3}")
+response_3 = chat.chat(customer_query_3)
+print(f"Assistant: {response_3}\n")
+
+# Example 4: Question with information not in the knowledge base
+customer_query_4 = "Do you have any books about quantum physics for beginners?"
+print(f"Customer: {customer_query_4}")
+response_4 = chat.chat(customer_query_4)
+print(f"Assistant: {response_4}\n")
+
+# Example 5: Combining information
+customer_query_5 = "Is free shipping available and what payment methods do you accept?"
+print(f"Customer: {customer_query_5}")
+response_5 = chat.chat(customer_query_5)
+print(f"Assistant: {response_5}\n")
+
+# Example 6: More nuanced query requiring retrieval
+customer_query_6 = "I want to return a book, what should I do?"
+print(f"Customer: {customer_query_6}")
+response_6 = chat.chat(customer_query_6)
+print(f"Assistant: {response_6}\n")