swarm-multiagent-orchestration.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use the OpenAI Swarm to orchestrate multiple agents\n",
    "\n",
    "Official Documentation: https://github.com/openai/swarm\n",
    "\n",
    "Medium Articile Reading: https://medium.com/ai-artistry/openai-swarm-vs-langchain-langgraph-a-detailed-look-at-multi-agent-frameworks-0f978a4ca203"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install Swarm in the Terminal\n",
    "# pip install git+https://github.com/openai/swarm.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import modules\n",
    "import os\n",
    "from dotenv import load_dotenv\n",
    "from swarm import Swarm, Agent\n",
    "from langchain_openai.llms import OpenAI\n",
    "from langchain_openai.chat_models import ChatOpenAI\n",
    "from langchain_core.prompts import PromptTemplate, ChatPromptTemplate\n",
    "from pydantic import BaseModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set your OpenAI API key\n",
    "load_dotenv()\n",
    "OpenAI.api_key = os.getenv(\"OPENAI_API_KEY\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A basic multi-agent orchestration example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Swarm client\n",
    "client = Swarm()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to allow the current agent to handoff to agent b\n",
    "def transfer_to_agent_b():\n",
    "    return agent_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create agent A and provide it with the function to handoff to agent B\n",
    "agent_a = Agent(\n",
    "    name=\"Agent A\",\n",
    "    instructions=\"You are a helpful agent.\",\n",
    "    functions=[transfer_to_agent_b],\n",
    ")\n",
    "\n",
    "# Create agent B (which does not have a function to handoff to agent A)\n",
    "agent_b = Agent(\n",
    "    name=\"Agent B\",\n",
    "    instructions=\"Only talk like a 5 year old.\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I can't make phone calls or do stuff with agents. But I can chat with you! Let's talk about fun things like cartoons or superheroes! 😊\n",
      "\n",
      "Agent B\n"
     ]
    }
   ],
   "source": [
    "# Run the client and print the response\n",
    "response = client.run(\n",
    "    # Start with agent A\n",
    "    agent=agent_a,\n",
    "    # Provide the innitial message to agent A\n",
    "    messages=[{\"role\": \"user\", \"content\": \"I want to talk to agent B.\"}],\n",
    ")\n",
    "\n",
    "print(response.messages[-1][\"content\"])\n",
    "print()\n",
    "print(response.agent.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The crimson leaves cascade gently from the trees, dancing through the crisp autumn air like fiery confetti celebrating the change of seasons.\n",
      "\n",
      "Agent A\n"
     ]
    }
   ],
   "source": [
    "# Run the client again with a different message and print the response.\n",
    "# Note: agent A can decide whether to handoff to agent B or not.\n",
    "response = client.run(\n",
    "    agent=agent_a,\n",
    "    messages=[{\"role\": \"user\", \"content\": \"Fall comes and the trees are turning red. Could you provide me with a one-sentence vivid description of the falling leaves?\"}],\n",
    ")\n",
    "\n",
    "print(response.messages[-1][\"content\"])\n",
    "print()\n",
    "print(response.agent.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create two agents that can discuss a given topic to improve the solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discussion Topic: Survey Question: \"On a scale of 1 to 10, how likely are you to recommend our product to a friend or colleague?\"\n",
      "\n",
      "Market Expert: Revised Survey Question: \"Based on your experience with our product, how likely are you to recommend it to someone you know?\"\n",
      "\n",
      "Justification: This revision personalizes the question by emphasizing the respondent's experience with the product, making it more relevant and encouraging a thoughtful response.\n",
      "\n",
      "Survey Expert: Revised Survey Question: \"Considering your recent usage, how would you rate your likelihood of recommending our product to a friend or colleague on a scale from 1 (very unlikely) to 10 (extremely likely)?\"\n",
      "\n",
      "Justification: This revision specifies the timeframe (\"recent usage\") to focus the respondent's assessment, retains the numerical scale for quantitative analysis, and clarifies the scale's meaning to ensure consistent understanding and responses.\n",
      "\n",
      "Market Expert: Revised Survey Question: \"Based on your recent experience, how likely are you to recommend our product to others, using a scale where 1 means 'not at all likely' and 10 means 'extremely likely'?\"\n",
      "\n",
      "Justification: This revision highlights the respondent's recent experience, provides clear guidelines for interpreting the scale, and maintains a focus on recommending behavior, ensuring both relevance and consistency in responses.\n",
      "\n",
      "Survey Expert: Revised Survey Question: \"Thinking about your most recent experience with our product, how likely are you to recommend it to others on a scale from 1 (not at all likely) to 10 (extremely likely)?\"\n",
      "\n",
      "Justification: This revision emphasizes the respondent's most recent experience for accurate recall and provides clear definitions for the endpoints of the scale to ensure clarity and consistency in responses.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Initialize the Swarm client\n",
    "client = Swarm()\n",
    "\n",
    "# Define agents for the discussion\n",
    "agent_market = Agent(\n",
    "    name=\"Market Expert\",\n",
    "    instructions=\"Revise the survey question further to make it more appropriate for the target customers. Provide the revised survey question with a single-sentence justification.\",\n",
    ")\n",
    "\n",
    "agent_survey = Agent(\n",
    "    name=\"Survey Expert\",\n",
    "    instructions=\"Revise the survey question further to make it scientifically sound and rigorous. Provide the revised survey question with a single-sentence justification.\",\n",
    ")\n",
    "\n",
    "# Define a discussion system function\n",
    "def discussion_system(agent_a, agent_b, topic, iterations):\n",
    "    messages = [{\"role\": \"user\", \"content\": topic}]\n",
    "    current_agent = agent_a\n",
    "\n",
    "    print(f\"Discussion Topic: {topic}\\n\")\n",
    "    \n",
    "    for i in range(iterations):\n",
    "        # Run the current agent with the latest messages\n",
    "        response = client.run(agent=current_agent, messages=messages)\n",
    "        \n",
    "        # Print the response from the current agent\n",
    "        print(f\"{current_agent.name}: {response.messages[-1]['content']}\")\n",
    "        print()\n",
    "        \n",
    "        # Add the agent's response to the conversation history\n",
    "        messages.append({\"role\": \"user\", \"content\": response.messages[-1][\"content\"]})\n",
    "        \n",
    "        # Alternate between agents\n",
    "        current_agent = agent_b if current_agent == agent_a else agent_a\n",
    "\n",
    "# Example usage\n",
    "discussion_topic = '''Survey Question: \"On a scale of 1 to 10, how likely are you to recommend our product to a friend or colleague?\"'''\n",
    "discussion_system(agent_market, agent_survey, discussion_topic, iterations=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create two agents that debate each other based on a topic given by the judge, and the judge decides which agent wins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Debate Topic: Highschool students should have PE every school day.\n",
      "\n",
      "--- Round 1 ---\n",
      "Debater A: High school students should have PE every school day as it promotes consistent physical activity, which is crucial for maintaining physical health, combating obesity, and reducing stress levels. Regular physical education classes also help students develop life-long healthy habits, improve mental health, and enhance overall academic performance by increasing focus and concentration. Furthermore, daily PE classes provide essential opportunities for social interaction and teamwork, which are key skills for personal and professional success.\n",
      "\n",
      "Debater B: Mandating PE every school day might lead to an imbalance in the academic curriculum, taking away precious time from core subjects where students need to build crucial knowledge and skills for college and future careers. Not all students are athletically inclined, and imposing daily physical education could increase stress and anxiety, detracting from their enjoyment and potentially harming their mental well-being. Additionally, schools with limited resources might struggle to provide diverse PE programs daily, leading to repetitive and less engaging activities that could decrease students’ motivation towards physical fitness.\n",
      "\n",
      "--- Round 2 ---\n",
      "Debater A: While it's important to balance academics and physical education, daily PE classes can enhance rather than detract from academic performance by improving students' focus and mental health, ultimately benefiting core subjects. Offering a variety of activities within PE curriculums can cater to different interests and skill levels, ensuring all students find enjoyment and reduce potential anxiety, promoting inclusivity and engagement. Moreover, prioritizing daily physical education encourages schools to innovate and effectively utilize resources, leading to creative solutions in implementing diverse and motivating PE programs that inspire lifelong fitness habits.\n",
      "\n",
      "Debater B: While it is true that physical education can enhance focus and mental health, the idea that daily PE will lead to better academic performance assumes that all students thrive in the same way, disregarding those who require more academically focused environments to excel. Diversifying PE activities may not be feasible in underfunded schools, leading to a drain on already stretched resources which could be better allocated towards academic improvement and support. Lastly, imposing daily PE could lead to increased pressure on time management for students who are already struggling to balance rigorous academic workloads, extra-curricular commitments, and personal responsibilities.\n",
      "\n",
      "--- Round 3 ---\n",
      "Debater A: Mandating daily PE can actually support students’ academic endeavors by serving as a much-needed outlet for stress relief and facilitating better time management skills, as regular physical activity has been shown to increase productivity and cognitive function. Furthermore, even in underfunded schools, incorporating simple and cost-effective physical activities can still promote significant health benefits, potentially reducing healthcare costs related to physical inactivity in the long run. Lastly, emphasizing physical education helps cultivate discipline and resilience, skills that are transferable to academic pursuits and essential for managing complex schedules effectively.\n",
      "\n",
      "Debater B: While physical activity certainly has its benefits, mandating daily PE could inadvertently prioritize it over other significant needs, like arts or STEM courses, which play an equally vital role in a well-rounded education and developing diverse talents. Schools already struggling with limited resources might find it challenging to maintain the necessary equipment and facilities for effective daily PE, potentially compromising the quality of these sessions and failing to deliver the intended benefits. Additionally, while physical activity can aid in developing discipline, enforced daily mandates risk turning PE into a compulsory chore rather than a genuine source of enjoyment and personal growth for students.\n",
      "\n",
      "--- Judge's Evaluation ---\n",
      "Judge: In evaluating the arguments presented, both sides bring valid points regarding the potential benefits and challenges of mandating daily physical education (PE) in high schools. The proponent emphasizes the numerous health benefits, enhancement of academic performance, and development of social skills through daily PE. Conversely, the opponent highlights concerns about resource constraints, the potential for exacerbating academic pressure, and the risk of diminishing other valuable educational experiences.\n",
      "\n",
      "The winner, in this case, is the side against mandating daily PE every school day. Their argument cogently addresses several realistic and practical challenges that many schools face, particularly resource allocation and balancing an already demanding academic curriculum. They appropriately highlight the diversity of students' needs and the potential for daily PE mandates to unintentionally prioritize physical education over other critical areas such as arts and STEM disciplines. Furthermore, their point about underfunded schools struggling to maintain effective daily PE programs underscores a significant concern regarding the feasibility and equity of implementing such a policy across varied educational environments.\n",
      "\n",
      "Therefore, while the benefits of physical education are undeniable, the opposing argument provides a more comprehensive consideration of the potential drawbacks and logistical issues that could arise from making PE a daily requirement. This nuanced approach better addresses the complexities and realities of implementing such a policy in diverse school settings.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Initialize the Swarm client\n",
    "client = Swarm()\n",
    "\n",
    "# Define the agents\n",
    "debater_a = Agent(\n",
    "    name=\"Debater A\",\n",
    "    instructions=\"Argue in favor of the provided statement. Use up to 3 sentences in your speech.\",\n",
    ")\n",
    "\n",
    "debater_b = Agent(\n",
    "    name=\"Debater B\",\n",
    "    instructions=\"Argue against the provided statement. Use up to 3 sentences in your speech.\",\n",
    ")\n",
    "\n",
    "judge = Agent(\n",
    "    name=\"Judge\",\n",
    "    instructions=\"Listen to both sides and declare a winner with justification.\",\n",
    ")\n",
    "\n",
    "# Define the debate system function\n",
    "def debate_system(judge, debater_a, debater_b, topic, rounds=3):\n",
    "    print(f\"Debate Topic: {topic}\\n\")\n",
    "\n",
    "    messages = [{\"role\": \"user\", \"content\": topic}]\n",
    "    \n",
    "    # Run the debate for the specified number of rounds\n",
    "    for round_num in range(1, rounds + 1):\n",
    "        print(f\"--- Round {round_num} ---\")\n",
    "        \n",
    "        # Debater A's turn\n",
    "        response_a = client.run(agent=debater_a, messages=messages)\n",
    "        print(f\"{debater_a.name}: {response_a.messages[-1]['content']}\\n\")\n",
    "        messages.append({\"role\": \"user\", \"content\": response_a.messages[-1][\"content\"]})\n",
    "        \n",
    "        # Debater B's turn\n",
    "        response_b = client.run(agent=debater_b, messages=messages)\n",
    "        print(f\"{debater_b.name}: {response_b.messages[-1]['content']}\\n\")\n",
    "        messages.append({\"role\": \"user\", \"content\": response_b.messages[-1][\"content\"]})\n",
    "    \n",
    "    # After the debate rounds, the judge provides comments and picks a winner\n",
    "    print(\"--- Judge's Evaluation ---\")\n",
    "    judge_response = client.run(agent=judge, messages=messages + [{\"role\": \"user\", \"content\": \"Please evaluate and decide a winner.\"}])\n",
    "    \n",
    "    # Print judge's final response with comments and winner\n",
    "    print(f\"{judge.name}: {judge_response.messages[-1]['content']}\\n\")\n",
    "\n",
    "# Example usage\n",
    "debate_topic = \"Highschool students should have PE every school day.\"\n",
    "debate_system(judge, debater_a, debater_b, topic=debate_topic, rounds=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Design two agents and a supervisor who chooses the most suitable agent to run a task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to report the weather\n",
    "def get_weather(city: str):\n",
    "    return f\"The weather in {city} is always 30°C.\"\n",
    "\n",
    "# Define a function to report the air quality\n",
    "def get_air_quality(city: str):\n",
    "    return f\"The air quality in {city} is 'Good' with an AQI of 42.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to route requests to the appropriate agent.\n",
    "# Note: The context_variables dictionary contains the last user message.\n",
    "def route_request(context_variables):\n",
    "    # Check if the user message contains \"weather\" or \"air quality\".\n",
    "    user_message = context_variables.get(\"last_user_message\", \"\")\n",
    "    \n",
    "    # Route the request to the appropriate agent based on the user message.\n",
    "    if \"weather\" in user_message.lower():\n",
    "        return weather_agent\n",
    "    elif \"air quality\" in user_message.lower():\n",
    "        return air_quality_agent\n",
    "    else:\n",
    "        return \"I'm sorry, I don't understand your request.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the weather agent\n",
    "weather_agent = Agent(\n",
    "    name=\"Weather Agent\",\n",
    "    instructions=\"You are a weather assistant. Provide the weather information when asked.\",\n",
    "    functions=[get_weather] # Provide the get_weather function to the agent\n",
    ")\n",
    "\n",
    "# Create the air quality agent\n",
    "air_quality_agent = Agent(\n",
    "    name=\"Air Quality Agent\",\n",
    "    instructions=\"You are an air quality assistant. Provide the air quality information when asked.\",\n",
    "    functions=[get_air_quality] # Provide the get_air_quality function to the agent\n",
    ")\n",
    "\n",
    "# Create the supervisor agent\n",
    "supervisor_agent = Agent(\n",
    "    name=\"Supervisor Agent\",\n",
    "    instructions=\"You are the supervisor. Determine whether the user's request is about weather or air quality, and transfer them to the appropriate agent by calling the 'route_request' function.\",\n",
    "    functions=[route_request] # Provide the route_request function to the agent\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Provide a user message and construct the context_variables dictionary\n",
    "user_message = \"What's the weather like in Paris?\"\n",
    "context_variables = {\"last_user_message\": user_message}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The current weather in Paris is 30°C.\n"
     ]
    }
   ],
   "source": [
    "# Run the client and print the response\n",
    "response = client.run(\n",
    "    # Start with the supervisor agent\n",
    "    agent=supervisor_agent,\n",
    "    # Provide the innitial message to the supervisor agent\n",
    "    messages=[{\"role\": \"user\", \"content\": user_message}],\n",
    "    # Provide the context variables to the supervisor agent\n",
    "    context_variables=context_variables\n",
    ")\n",
    "\n",
    "print(response.messages[-1][\"content\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The air quality in New York City is currently 'Good' with an Air Quality Index (AQI) of 42.\n"
     ]
    }
   ],
   "source": [
    "# Try a different user message\n",
    "user_message = \"How is the air quality in New York City?\"\n",
    "context_variables = {\"last_user_message\": user_message}\n",
    "\n",
    "response = client.run(\n",
    "    agent=supervisor_agent,\n",
    "    messages=[{\"role\": \"user\", \"content\": user_message}],\n",
    "    context_variables=context_variables\n",
    ")\n",
    "\n",
    "print(response.messages[-1][\"content\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It seems there is an issue with transferring your request. Please try asking again later, or check a reliable source for air quality information in New York City directly.\n"
     ]
    }
   ],
   "source": [
    "# However, because the route_request is hardcoded, it can be stubborn.\n",
    "user_message = \"How is the quality of air in New York City?\"\n",
    "context_variables = {\"last_user_message\": user_message}\n",
    "\n",
    "response = client.run(\n",
    "    agent=supervisor_agent,\n",
    "    messages=[{\"role\": \"user\", \"content\": user_message}],\n",
    "    context_variables=context_variables\n",
    ")\n",
    "\n",
    "print(response.messages[-1][\"content\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can allow the supervisor agent to route the agents based on semantic understanding of the task by making changes to the route_request function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a template using the pydantic basemodel\n",
    "class ChooseAgent(BaseModel):\n",
    "    '''Output an agent name based on the user's question.'''\n",
    "    agent_name: str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "agent_name='air_quality_agent'\n"
     ]
    }
   ],
   "source": [
    "# Build a chat prompt template\n",
    "template = ChatPromptTemplate.from_messages([\n",
    "    ('system', 'You are a helpful assistant.'),\n",
    "    ('human', \n",
    "    '''\n",
    "    You will determine whether the user's request is about weather or air quality. \n",
    "    If the request is about weather, you will output \"weather_agent\"; if the request is about air quality,\n",
    "    you will output \"air_quality_agent\"; and if the request is neither about weather nor about air quality, you return \"None\".\n",
    "    The user's request is: {request}.\n",
    "    '''),\n",
    "])\n",
    "\n",
    "# Call a chatmodel\n",
    "llm = ChatOpenAI()\n",
    "\n",
    "# Build the chain\n",
    "choose_agent_chain = template | llm.with_structured_output(ChooseAgent)\n",
    "\n",
    "# User's request\n",
    "request = \"How is the quality of air in New York City?\"\n",
    "\n",
    "# Invoke the chain\n",
    "result = choose_agent_chain.invoke({\n",
    "    \"request\": request,\n",
    "})\n",
    "\n",
    "# Print the result\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Based upon the above choose_agent_chain, we can create a more flexible route request fuction.\n",
    "def route_request_semantic(user_message): \n",
    "    # Invoke the chain to determine the agent to use.\n",
    "    result = choose_agent_chain.invoke({\n",
    "    \"request\": user_message,\n",
    "    })\n",
    "\n",
    "    # Route the request to the appropriate agent based on the user message.\n",
    "    if \"weather\" in result.agent_name.lower():\n",
    "        return weather_agent\n",
    "    elif \"air\" in result.agent_name.lower():\n",
    "        return air_quality_agent\n",
    "    else:\n",
    "        return \"I'm sorry, I don't understand your request.\"\n",
    "\n",
    "\n",
    "# Re-create the supervisor agent\n",
    "supervisor_agent_semantic = Agent(\n",
    "    name=\"Supervisor Agent\",\n",
    "    instructions=\"You are the supervisor. Determine whether the user's request is about weather or air quality, and transfer them to the appropriate agent by calling the 'route_request' function.\",\n",
    "    functions=[route_request_semantic]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The air quality in New York City is 'Good' with an AQI (Air Quality Index) of 42.\n"
     ]
    }
   ],
   "source": [
    "# Try the enhanced route request function\n",
    "user_message = \"How is the quality of air in New York City?\"\n",
    "context_variables = {\"last_user_message\": user_message}\n",
    "\n",
    "response = client.run(\n",
    "    agent=supervisor_agent_semantic,\n",
    "    messages=[{\"role\": \"user\", \"content\": user_message}],\n",
    "    context_variables=context_variables\n",
    ")\n",
    "\n",
    "print(response.messages[-1][\"content\"])"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}