Merge pull request #768 from giles17/openai_agent_features

Added OpenAI Agent Documentation for Agent Features

Author: dmytrostruk

agent-framework/user-guide/agents/agent-types/openai-assistants-agent.md

@@ -242,6 +242,118 @@ async def code_interpreter_example():
         print(result.text)
 ```
 
+### File Search
+
+Enable your assistant to search through uploaded documents:
+
+```python
+from agent_framework import HostedFileSearchTool, HostedVectorStoreContent
+
+async def create_vector_store(client: OpenAIAssistantsClient) -> tuple[str, HostedVectorStoreContent]:
+    """Create a vector store with sample documents."""
+    file = await client.client.files.create(
+        file=("todays_weather.txt", b"The weather today is sunny with a high of 75F."), 
+        purpose="user_data"
+    )
+    vector_store = await client.client.vector_stores.create(
+        name="knowledge_base",
+        expires_after={"anchor": "last_active_at", "days": 1},
+    )
+    result = await client.client.vector_stores.files.create_and_poll(
+        vector_store_id=vector_store.id, 
+        file_id=file.id
+    )
+    if result.last_error is not None:
+        raise Exception(f"Vector store file processing failed with status: {result.last_error.message}")
+
+    return file.id, HostedVectorStoreContent(vector_store_id=vector_store.id)
+
+async def delete_vector_store(client: OpenAIAssistantsClient, file_id: str, vector_store_id: str) -> None:
+    """Delete the vector store after using it."""
+    await client.client.vector_stores.delete(vector_store_id=vector_store_id)
+    await client.client.files.delete(file_id=file_id)
+
+async def file_search_example():
+    print("=== OpenAI Assistants Client Agent with File Search Example ===\n")
+
+    client = OpenAIAssistantsClient()
+    async with ChatAgent(
+        chat_client=client,
+        instructions="You are a helpful assistant that searches files in a knowledge base.",
+        tools=HostedFileSearchTool(),
+    ) as agent:
+        query = "What is the weather today? Do a file search to find the answer."
+        file_id, vector_store = await create_vector_store(client)
+
+        print(f"User: {query}")
+        print("Agent: ", end="", flush=True)
+        async for chunk in agent.run_stream(
+            query, tool_resources={"file_search": {"vector_store_ids": [vector_store.vector_store_id]}}
+        ):
+            if chunk.text:
+                print(chunk.text, end="", flush=True)
+        print()  # New line after streaming
+        
+        await delete_vector_store(client, file_id, vector_store.vector_store_id)
+```
+
+### Thread Management
+
+Maintain conversation context across multiple interactions:
+
+```python
+async def thread_example():
+    async with OpenAIAssistantsClient().create_agent(
+        name="Assistant",
+        instructions="You are a helpful assistant.",
+    ) as agent:
+        # Create a persistent thread for conversation context
+        thread = agent.get_new_thread()
+
+        # First interaction
+        first_query = "My name is Alice"
+        print(f"User: {first_query}")
+        first_result = await agent.run(first_query, thread=thread)
+        print(f"Agent: {first_result.text}")
+
+        # Second interaction - agent remembers the context
+        second_query = "What's my name?"
+        print(f"User: {second_query}")
+        second_result = await agent.run(second_query, thread=thread)
+        print(f"Agent: {second_result.text}")  # Should remember "Alice"
+```
+
+### Working with Existing Assistants
+
+You can reuse existing OpenAI assistants by providing their IDs:
+
+```python
+from openai import AsyncOpenAI
+
+async def existing_assistant_example():
+    # Create OpenAI client directly
+    client = AsyncOpenAI()
+    
+    # Create or get an existing assistant
+    assistant = await client.beta.assistants.create(
+        model="gpt-4o-mini",
+        name="WeatherAssistant",
+        instructions="You are a weather forecasting assistant."
+    )
+    
+    try:
+        # Use the existing assistant with Agent Framework
+        async with OpenAIAssistantsClient(
+            async_client=client,
+            assistant_id=assistant.id
+        ).create_agent() as agent:
+            result = await agent.run("What's the weather like in Seattle?")
+            print(result.text)
+    finally:
+        # Clean up the assistant
+        await client.beta.assistants.delete(assistant.id)
+```
+
 ### Streaming Responses
 
 Get responses as they are generated for better user experience:

agent-framework/user-guide/agents/agent-types/openai-chat-completion-agent.md

@@ -162,6 +162,72 @@ async def tools_example():
     print(result.text)
 ```
 
+### Web Search
+
+Enable real-time web search capabilities:
+
+```python
+from agent_framework import HostedWebSearchTool
+
+async def web_search_example():
+    agent = OpenAIChatClient(model_id="gpt-4o-search-preview").create_agent(
+        name="SearchBot",
+        instructions="You are a helpful assistant that can search the web for current information.",
+        tools=HostedWebSearchTool(),
+    )
+
+    result = await agent.run("What are the latest developments in artificial intelligence?")
+    print(result.text)
+```
+
+### Model Context Protocol (MCP) Tools
+
+Connect to local MCP servers for extended capabilities:
+
+```python
+from agent_framework import MCPStreamableHTTPTool
+
+async def local_mcp_example():
+    agent = OpenAIChatClient().create_agent(
+        name="DocsAgent",
+        instructions="You are a helpful assistant that can help with Microsoft documentation.",
+        tools=MCPStreamableHTTPTool(
+            name="Microsoft Learn MCP",
+            url="https://learn.microsoft.com/api/mcp",
+        ),
+    )
+
+    result = await agent.run("How do I create an Azure storage account using az cli?")
+    print(result.text)
+```
+
+### Thread Management
+
+Maintain conversation context across multiple interactions:
+
+```python
+async def thread_example():
+    agent = OpenAIChatClient().create_agent(
+        name="Agent",
+        instructions="You are a helpful assistant.",
+    )
+
+    # Create a persistent thread for conversation context
+    thread = agent.get_new_thread()
+
+    # First interaction
+    first_query = "My name is Alice"
+    print(f"User: {first_query}")
+    first_result = await agent.run(first_query, thread=thread)
+    print(f"Agent: {first_result.text}")
+
+    # Second interaction - agent remembers the context
+    second_query = "What's my name?"
+    print(f"User: {second_query}")
+    second_result = await agent.run(second_query, thread=thread)
+    print(f"Agent: {second_result.text}")  # Should remember "Alice"
+```
+
 ### Streaming Responses
 
 Get responses as they are generated for better user experience:
@@ -172,8 +238,8 @@ async def streaming_example():
         name="StoryTeller",
         instructions="You are a creative storyteller.",
     )
-
-    print("Assistant: ", end="", flush=True)
+    
+    print("Agent: ", end="", flush=True)
     async for chunk in agent.run_stream("Tell me a short story about AI."):
         if chunk.text:
             print(chunk.text, end="", flush=True)