agent-bootstrap-kit 1.0.0__py3-none-any.whl

agent_bootstrap_kit/scripts/plain_openai/1_multiturn_chat.py

@@ -0,0 +1,82 @@
+"""
+SCRIPT 1: Plain OpenAI SDK — Multi-Turn Conversation Agent
+===========================================================
+What it does:
+  - Maintains a conversation history (list of messages)
+  - Sends the FULL history on every API call so the model remembers context
+  - You type messages, it replies, forever — until you type 'quit'
+
+When to use this pattern:
+  - Chatbot, customer support bot, any conversational assistant
+
+Key concept:
+  - messages = [ {role, content}, {role, content}, ... ]
+  - Always append both the user message AND the assistant reply to keep memory
+"""
+
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+
+# ── Config ──────────────────────────────────────────────────
+load_dotenv()                          # reads OPENAI_API_KEY from .env file
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+MODEL  = "gpt-4o"                      # swap to gpt-4-turbo or gpt-3.5-turbo if needed
+
+# ── System prompt — defines the agent's persona ─────────────
+SYSTEM_PROMPT = """
+You are a helpful assistant. Answer clearly and concisely.
+If you don't know something, say so honestly.
+"""
+
+# ── Conversation history — this is how multi-turn memory works ──
+conversation_history = [
+    {"role": "system", "content": SYSTEM_PROMPT}
+]
+
+def chat(user_message: str) -> str:
+    """Send a message and get a reply. History is maintained automatically."""
+
+    # Step 1: Add the user's new message to history
+    conversation_history.append({
+        "role": "user",
+        "content": user_message
+    })
+
+    # Step 2: Send the FULL history to the API
+    response = client.chat.completions.create(
+        model=MODEL,
+        messages=conversation_history,   # <-- full history, not just latest message
+        temperature=0.7,
+        max_tokens=1000
+    )
+
+    # Step 3: Extract the assistant's reply
+    assistant_reply = response.choices[0].message.content
+
+    # Step 4: Add the assistant's reply to history so next turn remembers it
+    conversation_history.append({
+        "role": "assistant",
+        "content": assistant_reply
+    })
+
+    return assistant_reply
+
+
+# ── Main loop ────────────────────────────────────────────────
+if __name__ == "__main__":
+    print("Multi-Turn Chat Agent started. Type 'quit' to exit.\n")
+    print("-" * 50)
+
+    while True:
+        user_input = input("\nYou: ").strip()
+
+        if not user_input:
+            continue
+        if user_input.lower() in ["quit", "exit", "q"]:
+            print("Goodbye!")
+            break
+
+        response = chat(user_input)
+        print(f"\nAssistant: {response}")
+        print(f"\n[History length: {len(conversation_history)} messages]")

agent_bootstrap_kit/scripts/plain_openai/2_simple_agent_tools.py

@@ -0,0 +1,166 @@
+"""
+SCRIPT 2: Plain OpenAI SDK — Simple Agent with Tool Use (Function Calling)
+==========================================================================
+What it does:
+  - Defines Python functions as "tools" the model can call
+  - Model decides ON ITS OWN when to call a tool vs. answer directly
+  - Your code executes the tool and feeds the result back to the model
+  - Model uses the result to form the final answer
+
+When to use this pattern:
+  - Agent that needs to look up data, do calculations, call APIs, etc.
+
+Key concept:
+  - You define tools as JSON schemas (name + description + parameters)
+  - Model returns a tool_call instead of text when it wants to use a tool
+  - You run the actual Python function and return the result as a message
+  - Model then produces the final user-facing answer
+"""
+
+import os
+import json
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+MODEL  = "gpt-4o"
+
+# ── Step 1: Define your actual Python tool functions ────────
+def get_weather(city: str) -> str:
+    """Simulated weather lookup. Replace with real API call if available."""
+    fake_weather = {
+        "london": "Cloudy, 15°C",
+        "new york": "Sunny, 22°C",
+        "tokyo": "Rainy, 18°C",
+    }
+    return fake_weather.get(city.lower(), f"Weather data not available for {city}")
+
+
+def calculate(expression: str) -> str:
+    """Safely evaluate a math expression like '12 * 7 + 3'."""
+    try:
+        result = eval(expression, {"__builtins__": {}})  # restricted eval
+        return str(result)
+    except Exception as e:
+        return f"Error: {e}"
+
+
+# ── Step 2: Describe the tools to OpenAI in JSON schema format ──
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get the current weather for a given city",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "city": {
+                        "type": "string",
+                        "description": "The name of the city, e.g. 'London'"
+                    }
+                },
+                "required": ["city"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "calculate",
+            "description": "Evaluate a mathematical expression",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "expression": {
+                        "type": "string",
+                        "description": "A math expression like '12 * 7 + 3'"
+                    }
+                },
+                "required": ["expression"]
+            }
+        }
+    }
+]
+
+# Map tool names to actual Python functions
+TOOL_MAP = {
+    "get_weather": get_weather,
+    "calculate": calculate,
+}
+
+
+# ── Step 3: Agent loop — handles tool calls automatically ────
+def run_agent(user_message: str) -> str:
+    """
+    Agentic loop:
+    1. Send message to model
+    2. If model wants to call a tool → execute it → send result back
+    3. Repeat until model gives a final text answer
+    """
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant. Use tools when appropriate."},
+        {"role": "user",   "content": user_message}
+    ]
+
+    print(f"\nUser: {user_message}")
+
+    while True:
+        # Call the model
+        response = client.chat.completions.create(
+            model=MODEL,
+            messages=messages,
+            tools=TOOLS,
+            tool_choice="auto"   # model decides whether to use a tool
+        )
+
+        message = response.choices[0].message
+        finish_reason = response.choices[0].finish_reason
+
+        # ── Case A: Model wants to use a tool ───────────────
+        if finish_reason == "tool_calls":
+            print(f"\n[Agent is calling tools...]")
+
+            # Add model's tool-call message to history
+            messages.append(message)
+
+            # Execute each tool the model requested
+            for tool_call in message.tool_calls:
+                tool_name = tool_call.function.name
+                tool_args = json.loads(tool_call.function.arguments)
+
+                print(f"  → Tool: {tool_name}({tool_args})")
+
+                # Run the actual Python function
+                tool_result = TOOL_MAP[tool_name](**tool_args)
+                print(f"  ← Result: {tool_result}")
+
+                # Feed the result back into the conversation
+                messages.append({
+                    "role":         "tool",
+                    "tool_call_id": tool_call.id,
+                    "content":      str(tool_result)
+                })
+
+            # Loop again — model will now form the final answer
+
+        # ── Case B: Model has a final answer ────────────────
+        elif finish_reason == "stop":
+            final_answer = message.content
+            print(f"\nAssistant: {final_answer}")
+            return final_answer
+
+        else:
+            print(f"Unexpected finish_reason: {finish_reason}")
+            break
+
+
+# ── Main ─────────────────────────────────────────────────────
+if __name__ == "__main__":
+    print("Tool-Use Agent. Example queries:\n")
+    run_agent("What's the weather like in London?")
+    print("\n" + "="*50)
+    run_agent("What is 347 multiplied by 28?")
+    print("\n" + "="*50)
+    run_agent("Is it raining in Tokyo, and if so what's 15 percent of 200?")

agent_bootstrap_kit/scripts/semantic_kernel/5_sk_basic_agent.py

@@ -0,0 +1,135 @@
+"""
+SCRIPT 5: Semantic Kernel — Basic Agent with Plugin (Tool)
+==========================================================
+What it does:
+  - Creates a Semantic Kernel kernel (the core engine)
+  - Adds an OpenAI Chat Completion service
+  - Defines a Plugin (SK's name for a set of tools/functions)
+  - Runs a multi-turn conversation where the model can call plugin functions
+
+When to use this pattern:
+  - Microsoft SK is common in enterprise/.NET environments
+  - Good for structured workflows and plugin-based agents
+
+Key concepts:
+  - kernel      : the central object — configure services and plugins here
+  - Plugin      : a class with @kernel_function decorated methods = tools
+  - invoke()    : call a specific function directly
+  - chat loop   : use ChatCompletionAgent or manual chat_history for multi-turn
+"""
+
+import os
+import asyncio
+from dotenv import load_dotenv
+
+# Semantic Kernel imports
+from semantic_kernel import Kernel
+from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
+from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
+from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings
+from semantic_kernel.contents.chat_history import ChatHistory
+from semantic_kernel.core_plugins import TimePlugin
+from semantic_kernel.functions import kernel_function
+
+load_dotenv()
+
+# ── Step 1: Create and configure the Kernel ─────────────────
+kernel = Kernel()
+
+# Add OpenAI as the AI service
+kernel.add_service(
+    OpenAIChatCompletion(
+        service_id="openai_chat",
+        ai_model_id="gpt-4o",
+        api_key=os.getenv("OPENAI_API_KEY"),
+    )
+)
+
+
+# ── Step 2: Define a custom Plugin (set of tools) ────────────
+class WeatherPlugin:
+    """A simple plugin that provides weather information."""
+
+    @kernel_function(
+        name="get_weather",
+        description="Get the current weather for a specific city"
+    )
+    def get_weather(self, city: str) -> str:
+        """Returns simulated weather data for a city."""
+        weather_data = {
+            "london": "Overcast, 14°C, humidity 80%",
+            "new york": "Sunny, 23°C, humidity 45%",
+            "tokyo": "Light rain, 19°C, humidity 70%",
+            "mumbai": "Hot and humid, 33°C, humidity 85%",
+        }
+        return weather_data.get(
+            city.lower(),
+            f"Weather data not available for {city}"
+        )
+
+    @kernel_function(
+        name="get_forecast",
+        description="Get a 3-day weather forecast for a city"
+    )
+    def get_forecast(self, city: str) -> str:
+        """Returns a simulated 3-day forecast."""
+        return (
+            f"3-day forecast for {city}: "
+            f"Day 1: Cloudy 16°C | Day 2: Sunny 20°C | Day 3: Rain 13°C"
+        )
+
+
+# ── Step 3: Register plugins on the kernel ───────────────────
+kernel.add_plugin(WeatherPlugin(), plugin_name="weather")
+kernel.add_plugin(TimePlugin(), plugin_name="time")   # built-in SK plugin
+
+
+# ── Step 4: Multi-turn chat loop with auto function calling ──
+async def run_chat():
+    # Get the chat completion service
+    chat_service = kernel.get_service("openai_chat")
+
+    # Settings: allow the model to auto-call our plugin functions
+    settings = OpenAIChatPromptExecutionSettings(
+        service_id="openai_chat",
+        function_choice_behavior=FunctionChoiceBehavior.Auto(
+            filters={"included_plugins": ["weather", "time"]}
+        )
+    )
+
+    # Chat history maintains multi-turn memory
+    chat_history = ChatHistory()
+    chat_history.add_system_message(
+        "You are a helpful weather assistant. "
+        "Use the weather plugin to answer questions about weather. "
+        "Be friendly and informative."
+    )
+
+    print("Semantic Kernel Weather Agent. Type 'quit' to exit.\n")
+    print("-" * 50)
+
+    while True:
+        user_input = input("\nYou: ").strip()
+        if not user_input or user_input.lower() in ["quit", "exit"]:
+            print("Goodbye!")
+            break
+
+        # Add user message to history
+        chat_history.add_user_message(user_input)
+
+        # Get response — SK will auto-invoke plugin functions if needed
+        response = await chat_service.get_chat_message_content(
+            chat_history=chat_history,
+            settings=settings,
+            kernel=kernel,
+        )
+
+        print(f"\nAssistant: {response}")
+
+        # Add assistant response to history
+        chat_history.add_assistant_message(str(response))
+
+
+# ── Main ─────────────────────────────────────────────────────
+if __name__ == "__main__":
+    asyncio.run(run_chat())

agent_bootstrap_kit/scripts/semantic_kernel/6_sk_workflow.py

@@ -0,0 +1,184 @@
+"""
+SCRIPT 6: Semantic Kernel — Sequential Workflow (Step-by-Step Plan)
+====================================================================
+What it does:
+  - Manually chains multiple SK functions into a workflow pipeline
+  - Each step's output feeds into the next step
+  - Models a real-world multi-step processing workflow
+
+When to use this pattern:
+  - Document processing pipelines
+  - Data transformation workflows
+  - Any "do A, then use A's output to do B" scenario
+
+Key concepts:
+  - kernel.invoke()          : run one function
+  - KernelArguments          : pass inputs and carry context between steps
+  - Prompt functions         : define LLM steps as string templates with {{$input}}
+  - Native functions         : define Python logic steps using @kernel_function
+"""
+
+import os
+import asyncio
+from dotenv import load_dotenv
+
+from semantic_kernel import Kernel
+from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
+from semantic_kernel.functions import kernel_function, KernelArguments
+from semantic_kernel.prompt_template import PromptTemplateConfig
+
+load_dotenv()
+
+# ── Setup kernel ─────────────────────────────────────────────
+kernel = Kernel()
+kernel.add_service(
+    OpenAIChatCompletion(
+        service_id="openai_chat",
+        ai_model_id="gpt-4o",
+        api_key=os.getenv("OPENAI_API_KEY"),
+    )
+)
+
+
+# ── Define workflow steps as a Plugin ────────────────────────
+class DocumentWorkflowPlugin:
+    """
+    Simulates a document processing workflow:
+    Step 1 (native): Validate/clean the input text
+    Step 2 (prompt): Summarize the text using AI
+    Step 3 (prompt): Extract key action items using AI
+    Step 4 (native): Format the final output
+    """
+
+    @kernel_function(
+        name="validate_input",
+        description="Validate and clean the input text"
+    )
+    def validate_input(self, text: str) -> str:
+        """Native (Python) function — no LLM needed."""
+        if not text or len(text.strip()) < 10:
+            raise ValueError("Input text is too short or empty")
+        # Clean up whitespace
+        cleaned = " ".join(text.split())
+        print(f"  [Step 1] Input validated. Length: {len(cleaned)} chars")
+        return cleaned
+
+    @kernel_function(
+        name="format_output",
+        description="Format the final workflow result into a structured report"
+    )
+    def format_output(self, summary: str, action_items: str, original_length: int) -> str:
+        """Native (Python) function — formats the final result."""
+        report = f"""
+╔══════════════════════════════════════════════╗
+║           DOCUMENT PROCESSING REPORT         ║
+╚══════════════════════════════════════════════╝
+
+ORIGINAL LENGTH  : {original_length} characters
+
+SUMMARY
+───────
+{summary.strip()}
+
+ACTION ITEMS
+────────────
+{action_items.strip()}
+
+╔══════════════════════════════════════════════╗
+║                END OF REPORT                 ║
+╚══════════════════════════════════════════════╝
+"""
+        return report
+
+
+# ── Register plugin ──────────────────────────────────────────
+kernel.add_plugin(DocumentWorkflowPlugin(), plugin_name="workflow")
+
+# ── Register AI-powered prompt functions ─────────────────────
+
+# Summarize function — uses LLM
+summarize_function = kernel.add_function(
+    plugin_name="workflow",
+    function_name="summarize",
+    prompt="Summarize the following text in 3-4 sentences:\n\n{{$input}}",
+    prompt_template_settings=PromptTemplateConfig(
+        template="Summarize the following text in 3-4 sentences:\n\n{{$input}}"
+    )
+)
+
+# Extract action items function — uses LLM
+extract_actions_function = kernel.add_function(
+    plugin_name="workflow",
+    function_name="extract_actions",
+    prompt="""From the following text, extract any action items, tasks, or next steps.
+Format as a numbered list. If none found, say 'No action items identified.'
+
+Text: {{$input}}""",
+    prompt_template_settings=PromptTemplateConfig(
+        template="""From the following text, extract any action items, tasks, or next steps.
+Format as a numbered list. If none found, say 'No action items identified.'
+
+Text: {{$input}}"""
+    )
+)
+
+
+# ── Run the workflow ─────────────────────────────────────────
+async def run_workflow(input_text: str):
+    print("\nStarting Document Processing Workflow...")
+    print("=" * 50)
+
+    # Step 1: Validate input (native Python)
+    print("\n[Step 1] Validating input...")
+    step1_result = await kernel.invoke(
+        kernel.plugins["workflow"]["validate_input"],
+        KernelArguments(text=input_text)
+    )
+    clean_text = str(step1_result)
+    original_length = len(clean_text)
+
+    # Step 2: Summarize with AI
+    print("[Step 2] Generating summary with AI...")
+    step2_result = await kernel.invoke(
+        kernel.plugins["workflow"]["summarize"],
+        KernelArguments(input=clean_text)
+    )
+    summary = str(step2_result)
+
+    # Step 3: Extract action items with AI
+    print("[Step 3] Extracting action items with AI...")
+    step3_result = await kernel.invoke(
+        kernel.plugins["workflow"]["extract_actions"],
+        KernelArguments(input=clean_text)
+    )
+    action_items = str(step3_result)
+
+    # Step 4: Format final output (native Python)
+    print("[Step 4] Formatting final report...")
+    final_result = await kernel.invoke(
+        kernel.plugins["workflow"]["format_output"],
+        KernelArguments(
+            summary=summary,
+            action_items=action_items,
+            original_length=original_length
+        )
+    )
+
+    print("\n" + str(final_result))
+    return str(final_result)
+
+
+# ── Main ─────────────────────────────────────────────────────
+if __name__ == "__main__":
+    sample_document = """
+    Our Q3 product review meeting covered several important topics.
+    The mobile app team needs to fix the login bug by end of week.
+    Revenue is up 15% compared to last quarter, driven by enterprise sales.
+    John needs to prepare the board presentation by Friday.
+    The infrastructure team should upgrade the database servers before the holiday freeze.
+    Customer satisfaction scores improved after the recent UX redesign.
+    Sarah will follow up with the three key enterprise clients who haven't renewed.
+    We agreed to hold a retrospective next Monday at 10am.
+    """
+
+    asyncio.run(run_workflow(sample_document))

agent_bootstrap_kit/scripts/setup.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# ============================================================
+# BOOTSTRAP SETUP SCRIPT
+# Run this first on the VM to install all required packages
+# Usage: bash setup.sh
+# ============================================================
+
+echo "Installing all required packages..."
+
+# Core OpenAI SDK
+pip install openai --quiet
+
+# AutoGen (Microsoft multi-agent framework)
+pip install pyautogen --quiet
+
+# Semantic Kernel (Microsoft SK framework)
+pip install semantic-kernel --quiet
+
+# Azure AI Agent Service SDK
+pip install azure-ai-projects azure-identity --quiet
+
+# Utility
+pip install python-dotenv --quiet
+
+echo ""
+echo "All packages installed successfully!"
+echo ""
+echo "Next step: copy your OpenAI API key into a .env file:"
+echo "  OPENAI_API_KEY=sk-..."
+echo ""
+echo "Then run any of the example scripts:"
+echo "  python plain_openai/1_multiturn_chat.py"
+echo "  python plain_openai/2_simple_agent_tools.py"
+echo "  python autogen/3_autogen_two_agent.py"
+echo "  python autogen/4_autogen_tool_use.py"
+echo "  python semantic_kernel/5_sk_basic_agent.py"
+echo "  python semantic_kernel/6_sk_planner.py"
+echo "  python azure_ai_agent/7_azure_agent_thread.py"

agent_bootstrap_kit-1.0.0.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: agent-bootstrap-kit
+Version: 1.0.0
+Summary: OpenAI agent bootstrap scripts for assessments
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pyautogen>=0.2.0
+Requires-Dist: semantic-kernel>=1.0.0
+Requires-Dist: azure-ai-projects>=1.0.0
+Requires-Dist: azure-identity>=1.0.0
+
+# agent-bootstrap-kit
+
+Bootstrap scripts for building OpenAI agents — multi-turn chat, tool use, AutoGen, Semantic Kernel, and Azure AI Agent Service.
+
+## Install
+
+```bash
+pip install agent-bootstrap-kit
+```
+
+## Extract scripts to your current folder
+
+```bash
+agent-bootstrap
+```
+
+Or in Python:
+
+```python
+from agent_bootstrap_kit import extract
+extract()
+```
+
+## What gets extracted
+
+```
+plain_openai/
+    1_multiturn_chat.py         # Multi-turn conversation agent
+    2_simple_agent_tools.py     # Agent with tool/function calling
+
+autogen/
+    3_autogen_two_agent.py      # AutoGen two-agent conversation
+    4_autogen_tool_use.py       # AutoGen agent with tools
+
+semantic_kernel/
+    5_sk_basic_agent.py         # Semantic Kernel agent with plugin
+    6_sk_workflow.py            # Semantic Kernel multi-step pipeline
+
+azure_ai_agent/
+    7_azure_agent_thread.py     # Azure AI Agent Service (thread-based)
+
+EXAM_DAY_REFERENCE.py           # Quick reference — which script to use when
+setup.sh                        # Install all dependencies in one command
+.env.template                   # Copy → .env, add your API key
+```
+
+## Quick start after extraction
+
+```bash
+# 1. Add your API key
+cp .env.template .env
+# Edit .env: OPENAI_API_KEY=sk-...
+
+# 2. Install dependencies
+bash setup.sh
+
+# 3. Run a script
+python plain_openai/1_multiturn_chat.py
+```
+
+## Requirements
+
+- Python 3.9+
+- An OpenAI API key