upgrade model from GPT-3.5 to GPT-4o-mini

notebooks/Prompting_101.ipynb

@@ -3,11 +3,11 @@
     {
       "cell_type": "markdown",
       "metadata": {
-        "colab_type": "text",
-        "id": "view-in-github"
+        "id": "view-in-github",
+        "colab_type": "text"
       },
       "source": [
-        "<a href=\"https://colab.research.google.com/github/towardsai/ai-tutor-rag-system/blob/main/notebooks/Prompting_101.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n"
+        "<a href=\"https://colab.research.google.com/github/towardsai/ai-tutor-rag-system/blob/main/notebooks/Prompting_101.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
       ]
     },
     {
@@ -21,23 +21,23 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 1,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
         "id": "o4Q0N2omkAoZ",
-        "outputId": "6bc470f0-2efe-4cd8-d3e3-1b20593ad968"
+        "outputId": "a4c076e4-139d-48ca-9b35-b75c06c619b3"
       },
       "outputs": [
         {
-          "name": "stdout",
           "output_type": "stream",
+          "name": "stdout",
           "text": [
-            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m320.6/320.6 kB\u001b[0m \u001b[31m2.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m4.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m3.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/337.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m\u001b[90m━\u001b[0m \u001b[32m327.7/337.0 kB\u001b[0m \u001b[31m10.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m337.0/337.0 kB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.4/76.4 kB\u001b[0m \u001b[31m4.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m4.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
             "\u001b[?25h"
           ]
         }
@@ -48,7 +48,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 2,
+      "execution_count": null,
       "metadata": {
         "id": "xxK7EAAvr2aT"
       },
@@ -71,7 +71,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": null,
       "metadata": {
         "id": "La8hdWqJkFkh"
       },
@@ -111,7 +111,7 @@
       "outputs": [],
       "source": [
         "response = client.chat.completions.create(\n",
-        "    model=\"gpt-4o\",\n",
+        "    model=\"gpt-4o-mini\",\n",
         "    temperature=0.0,\n",
         "    messages=[{\"role\": \"user\", \"content\": \"How AI can help my project?\"}],\n",
         ")"
@@ -125,64 +125,36 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "ET_l06LiojaN",
-        "outputId": "72207c84-8d4f-4e5c-bfda-2d850b4b4a5b"
+        "outputId": "e80e1b00-7340-4939-e9f4-db60cc569f11"
       },
       "outputs": [
         {
-          "name": "stdout",
           "output_type": "stream",
+          "name": "stdout",
           "text": [
-            "AI can significantly enhance your project in various ways, depending on the nature and goals of your project. Here are some general areas where AI can be beneficial:\n",
-            "\n",
-            "### 1. **Data Analysis and Insights**\n",
-            "- **Predictive Analytics:** AI can analyze historical data to predict future trends, helping you make informed decisions.\n",
-            "- **Pattern Recognition:** AI algorithms can identify patterns and correlations in large datasets that might be missed by human analysis.\n",
+            "AI can assist your project in various ways, depending on its nature and goals. Here are some general ways AI can be beneficial:\n",
             "\n",
-            "### 2. **Automation**\n",
-            "- **Task Automation:** Automate repetitive tasks such as data entry, scheduling, and customer service.\n",
-            "- **Process Optimization:** AI can streamline workflows and improve efficiency by optimizing processes.\n",
+            "1. **Data Analysis**: AI can process and analyze large datasets quickly, identifying patterns and insights that may not be immediately apparent. This can help in making informed decisions.\n",
             "\n",
-            "### 3. **Personalization**\n",
-            "- **Customer Experience:** Use AI to personalize user experiences, such as recommending products or content based on user behavior.\n",
-            "- **Targeted Marketing:** AI can help segment your audience and create targeted marketing campaigns.\n",
+            "2. **Automation**: AI can automate repetitive tasks, freeing up time for you and your team to focus on more strategic activities. This can include data entry, scheduling, or even customer service through chatbots.\n",
             "\n",
-            "### 4. **Natural Language Processing (NLP)**\n",
-            "- **Chatbots:** Implement AI-driven chatbots to handle customer inquiries, providing instant support and freeing up human resources.\n",
-            "- **Sentiment Analysis:** Analyze customer feedback and social media to gauge public sentiment about your project or product.\n",
+            "3. **Predictive Analytics**: AI can help forecast trends and outcomes based on historical data, which can be useful for project planning, risk management, and resource allocation.\n",
             "\n",
-            "### 5. **Image and Video Analysis**\n",
-            "- **Computer Vision:** Use AI to analyze images and videos for various applications, such as quality control, security, and content moderation.\n",
-            "- **Facial Recognition:** Implement facial recognition for security or personalized user experiences.\n",
+            "4. **Personalization**: If your project involves user interaction, AI can help tailor experiences to individual users by analyzing their behavior and preferences, enhancing user satisfaction.\n",
             "\n",
-            "### 6. **Decision Support**\n",
-            "- **Recommendation Systems:** AI can provide recommendations based on data analysis, helping you make better decisions.\n",
-            "- **Risk Assessment:** AI can evaluate risks and provide insights to mitigate them.\n",
+            "5. **Natural Language Processing (NLP)**: If your project involves text or speech, AI can help with tasks like sentiment analysis, language translation, or content generation.\n",
             "\n",
-            "### 7. **Development and Testing**\n",
-            "- **Code Generation:** AI tools can assist in writing and debugging code, speeding up the development process.\n",
-            "- **Automated Testing:** Use AI to automate software testing, ensuring higher quality and faster release cycles.\n",
+            "6. **Image and Video Analysis**: For projects involving visual data, AI can assist in image recognition, object detection, and video analysis, which can be useful in fields like security, healthcare, and marketing.\n",
             "\n",
-            "### 8. **Resource Management**\n",
-            "- **Supply Chain Optimization:** AI can optimize inventory management, demand forecasting, and logistics.\n",
-            "- **Human Resources:** AI can assist in talent acquisition, performance evaluation, and employee engagement.\n",
+            "7. **Enhanced Collaboration**: AI tools can facilitate better communication and collaboration among team members, providing insights and recommendations based on project data.\n",
             "\n",
-            "### 9. **Innovation and Creativity**\n",
-            "- **Idea Generation:** AI can help brainstorm new ideas by analyzing existing data and trends.\n",
-            "- **Content Creation:** Use AI to generate content, such as articles, reports, or even creative writing.\n",
+            "8. **Resource Optimization**: AI can help optimize resource allocation, ensuring that your project runs efficiently and within budget.\n",
             "\n",
-            "### 10. **Security**\n",
-            "- **Fraud Detection:** AI can identify unusual patterns that may indicate fraudulent activity.\n",
-            "- **Cybersecurity:** AI can help detect and respond to security threats in real-time.\n",
+            "9. **Risk Management**: AI can identify potential risks and suggest mitigation strategies based on data analysis, helping you to proactively address issues before they escalate.\n",
             "\n",
-            "### Steps to Implement AI in Your Project\n",
-            "1. **Identify Needs:** Determine which aspects of your project could benefit from AI.\n",
-            "2. **Data Collection:** Gather the necessary data that AI will need to function effectively.\n",
-            "3. **Choose the Right Tools:** Select AI tools and platforms that fit your project requirements.\n",
-            "4. **Develop and Train Models:** Develop AI models and train them using your data.\n",
-            "5. **Integration:** Integrate AI solutions into your existing systems and workflows.\n",
-            "6. **Monitor and Optimize:** Continuously monitor the performance of AI systems and make adjustments as needed.\n",
+            "10. **Feedback and Improvement**: AI can analyze feedback from stakeholders and users, providing insights that can help improve the project over time.\n",
             "\n",
-            "By leveraging AI, you can enhance efficiency, improve decision-making, and create more personalized and effective solutions for your project.\n"
+            "To provide more specific suggestions, it would be helpful to know more about the nature of your project, its goals, and the challenges you are facing.\n"
           ]
         }
       ],
@@ -208,7 +180,7 @@
       "outputs": [],
       "source": [
         "response = client.chat.completions.create(\n",
-        "    model=\"gpt-4o\",\n",
+        "    model=\"gpt-4o-mini\",\n",
         "    temperature=0.0,\n",
         "    messages=[{\"role\": \"user\", \"content\": \"How can I do summarization using AI?\"}],\n",
         ")"
@@ -222,156 +194,66 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "0PfYfRCbuFiK",
-        "outputId": "dcd51828-493f-4a09-9803-be7c0cdf12f4"
+        "outputId": "c096d8e3-d9fe-4964-f76a-e67cee5806e8"
       },
       "outputs": [
         {
-          "name": "stdout",
           "output_type": "stream",
+          "name": "stdout",
           "text": [
-            "Summarization using AI involves using machine learning models to condense a large body of text into a shorter version while retaining the key information and main ideas. There are two main types of summarization techniques: extractive and abstractive.\n",
-            "\n",
-            "1. **Extractive Summarization**: This method involves selecting important sentences, phrases, or sections directly from the source text and concatenating them to create a summary. It doesn't generate new sentences but rather extracts and combines parts of the original text.\n",
-            "\n",
-            "2. **Abstractive Summarization**: This method involves generating new sentences that convey the main ideas of the source text. It is more complex as it requires understanding the context and rephrasing the content in a coherent manner.\n",
-            "\n",
-            "Here are some steps and tools you can use to perform summarization using AI:\n",
-            "\n",
-            "### Using Pre-trained Models and Libraries\n",
-            "\n",
-            "1. **Hugging Face Transformers**:\n",
-            "   - Hugging Face provides a library called `transformers` which includes pre-trained models for both extractive and abstractive summarization.\n",
-            "   - Models like BART, T5, and Pegasus are popular for abstractive summarization.\n",
-            "\n",
-            "   ```python\n",
-            "   from transformers import pipeline\n",
-            "\n",
-            "   # Load the summarization pipeline\n",
-            "   summarizer = pipeline(\"summarization\")\n",
-            "\n",
-            "   # Input text\n",
-            "   text = \"\"\"\n",
-            "   Your long text goes here...\n",
-            "   \"\"\"\n",
-            "\n",
-            "   # Generate summary\n",
-            "   summary = summarizer(text, max_length=150, min_length=30, do_sample=False)\n",
-            "   print(summary[0]['summary_text'])\n",
-            "   ```\n",
-            "\n",
-            "2. **spaCy and Sumy**:\n",
-            "   - `spaCy` is a popular NLP library that can be used in conjunction with `Sumy` for extractive summarization.\n",
-            "\n",
-            "   ```python\n",
-            "   import spacy\n",
-            "   from sumy.parsers.plaintext import PlaintextParser\n",
-            "   from sumy.nlp.tokenizers import Tokenizer\n",
-            "   from sumy.summarizers.lsa import LsaSummarizer\n",
-            "\n",
-            "   # Load spaCy model\n",
-            "   nlp = spacy.load('en_core_web_sm')\n",
-            "\n",
-            "   # Input text\n",
-            "   text = \"\"\"\n",
-            "   Your long text goes here...\n",
-            "   \"\"\"\n",
-            "\n",
-            "   # Parse the text\n",
-            "   parser = PlaintextParser.from_string(text, Tokenizer(\"english\"))\n",
-            "\n",
-            "   # Summarize using LSA\n",
-            "   summarizer = LsaSummarizer()\n",
-            "   summary = summarizer(parser.document, 3)  # Summarize to 3 sentences\n",
-            "\n",
-            "   for sentence in summary:\n",
-            "       print(sentence)\n",
-            "   ```\n",
-            "\n",
-            "### Using Online Services\n",
-            "\n",
-            "1. **OpenAI GPT-3**:\n",
-            "   - OpenAI's GPT-3 can be used for summarization tasks. You can access it via the OpenAI API.\n",
-            "\n",
-            "   ```python\n",
-            "   import openai\n",
-            "\n",
-            "   openai.api_key = 'your-api-key'\n",
-            "\n",
-            "   response = openai.Completion.create(\n",
-            "       engine=\"text-davinci-003\",\n",
-            "       prompt=\"Summarize the following text:\\n\\nYour long text goes here...\",\n",
-            "       max_tokens=150\n",
-            "   )\n",
-            "\n",
-            "   print(response.choices[0].text.strip())\n",
-            "   ```\n",
-            "\n",
-            "2. **Google Cloud Natural Language API**:\n",
-            "   - Google Cloud offers a Natural Language API that includes features for text analysis and summarization.\n",
-            "\n",
-            "### Custom Models\n",
-            "\n",
-            "If you have specific requirements or a unique dataset, you might want to train your own summarization model. This involves:\n",
-            "\n",
-            "1. **Data Collection**: Gather a large dataset of documents and their corresponding summaries.\n",
-            "2. **Preprocessing**: Clean and preprocess the text data.\n",
-            "3. **Model Training**: Use frameworks like TensorFlow or PyTorch to train a model. You can start with a pre-trained model and fine-tune it on your dataset.\n",
-            "4. **Evaluation**: Evaluate the model using metrics like ROUGE to ensure it generates high-quality summaries.\n",
-            "\n",
-            "### Example of Fine-Tuning a Model\n",
-            "\n",
-            "```python\n",
-            "from transformers import T5Tokenizer, T5ForConditionalGeneration, Trainer, TrainingArguments\n",
-            "\n",
-            "# Load pre-trained model and tokenizer\n",
-            "model = T5ForConditionalGeneration.from_pretrained('t5-small')\n",
-            "tokenizer = T5Tokenizer.from_pretrained('t5-small')\n",
-            "\n",
-            "# Prepare dataset (example)\n",
-            "train_texts = [\"Your training texts...\"]\n",
-            "train_summaries = [\"Your training summaries...\"]\n",
-            "\n",
-            "# Tokenize data\n",
-            "train_encodings = tokenizer(train_texts, truncation=True, padding=True, max_length=512)\n",
-            "train_labels = tokenizer(train_summaries, truncation=True, padding=True, max_length=150)\n",
-            "\n",
-            "# Create dataset\n",
-            "class SummarizationDataset(torch.utils.data.Dataset):\n",
-            "    def __init__(self, encodings, labels):\n",
-            "        self.encodings = encodings\n",
-            "        self.labels = labels\n",
-            "\n",
-            "    def __getitem__(self, idx):\n",
-            "        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}\n",
-            "        item['labels'] = torch.tensor(self.labels['input_ids'][idx])\n",
-            "        return item\n",
-            "\n",
-            "    def __len__(self):\n",
-            "        return len(self.encodings['input_ids'])\n",
-            "\n",
-            "train_dataset = SummarizationDataset(train_encodings, train_labels)\n",
-            "\n",
-            "# Training arguments\n",
-            "training_args = TrainingArguments(\n",
-            "    output_dir='./results',\n",
-            "    num_train_epochs=3,\n",
-            "    per_device_train_batch_size=4,\n",
-            "    save_steps=10_000,\n",
-            "    save_total_limit=2,\n",
-            ")\n",
-            "\n",
-            "# Trainer\n",
-            "trainer = Trainer(\n",
-            "    model=model,\n",
-            "    args=training_args,\n",
-            "    train_dataset=train_dataset,\n",
-            ")\n",
-            "\n",
-            "# Train model\n",
-            "trainer.train()\n",
-            "```\n",
-            "\n",
-            "By following these steps and using the appropriate tools, you can effectively perform text summarization using AI.\n"
+            "Summarization using AI can be accomplished through various methods and tools, depending on your specific needs and the type of content you want to summarize. Here are some approaches you can consider:\n",
+            "\n",
+            "### 1. **Using Pre-trained Models**\n",
+            "   - **Transformers**: Models like BERT, GPT, and T5 can be fine-tuned for summarization tasks. Libraries like Hugging Face's Transformers provide pre-trained models that can be used directly for summarization.\n",
+            "   - **Example**: You can use the `pipeline` function from the Hugging Face library to summarize text easily.\n",
+            "     ```python\n",
+            "     from transformers import pipeline\n",
+            "\n",
+            "     summarizer = pipeline(\"summarization\")\n",
+            "     text = \"Your long text goes here.\"\n",
+            "     summary = summarizer(text, max_length=50, min_length=25, do_sample=False)\n",
+            "     print(summary)\n",
+            "     ```\n",
+            "\n",
+            "### 2. **Using Online Tools**\n",
+            "   - There are several online platforms that offer AI-based summarization services. Some popular ones include:\n",
+            "     - **SMMRY**: A simple tool that summarizes text by removing unnecessary sentences.\n",
+            "     - **Resoomer**: Focuses on summarizing argumentative texts.\n",
+            "     - **QuillBot**: Offers a summarization feature along with paraphrasing tools.\n",
+            "\n",
+            "### 3. **Custom Model Training**\n",
+            "   - If you have specific requirements or a unique dataset, you can train your own summarization model. This typically involves:\n",
+            "     - Collecting a dataset of documents and their summaries.\n",
+            "     - Preprocessing the data (tokenization, cleaning, etc.).\n",
+            "     - Training a model using frameworks like TensorFlow or PyTorch.\n",
+            "     - Evaluating the model's performance using metrics like ROUGE.\n",
+            "\n",
+            "### 4. **Extractive vs. Abstractive Summarization**\n",
+            "   - **Extractive Summarization**: This method selects key sentences or phrases from the original text to create a summary. Algorithms like TextRank or using BERT embeddings can be effective.\n",
+            "   - **Abstractive Summarization**: This method generates new sentences that capture the essence of the original text. It often requires more advanced models like GPT or T5.\n",
+            "\n",
+            "### 5. **APIs for Summarization**\n",
+            "   - Several companies provide APIs for text summarization, such as:\n",
+            "     - **OpenAI's GPT-3/4**: You can use the API to generate summaries by providing prompts.\n",
+            "     - **Google Cloud Natural Language API**: Offers various NLP capabilities, including summarization.\n",
+            "\n",
+            "### 6. **Using Python Libraries**\n",
+            "   - Libraries like `sumy`, `gensim`, and `spaCy` can be used for summarization tasks.\n",
+            "   - **Example with Gensim**:\n",
+            "     ```python\n",
+            "     from gensim.summarization import summarize\n",
+            "\n",
+            "     text = \"Your long text goes here.\"\n",
+            "     summary = summarize(text, ratio=0.2)  # Summarize to 20% of the original text\n",
+            "     print(summary)\n",
+            "     ```\n",
+            "\n",
+            "### 7. **Considerations**\n",
+            "   - **Quality of Input**: The quality of the summary often depends on the quality and clarity of the input text.\n",
+            "   - **Length and Complexity**: Longer and more complex texts may require more sophisticated models or additional fine-tuning.\n",
+            "   - **Evaluation**: Always evaluate the summaries generated by AI against human-generated summaries to ensure quality.\n",
+            "\n",
+            "By choosing the right method and tools based on your requirements, you can effectively use AI for summarization tasks.\n"
           ]
         }
       ],
@@ -397,7 +279,7 @@
       "outputs": [],
       "source": [
         "response = client.chat.completions.create(\n",
-        "    model=\"gpt-4o\",\n",
+        "    model=\"gpt-4o-mini\",\n",
         "    temperature=0.0,\n",
         "    messages=[\n",
         "        {\n",
@@ -416,86 +298,59 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "QyIsGPp4AnVY",
-        "outputId": "0fc515ef-2e5a-4146-ca57-2147d5a04610"
+        "outputId": "88b350f5-63a8-44e5-bb6d-4c7a34e8626b"
       },
       "outputs": [
         {
-          "name": "stdout",
           "output_type": "stream",
+          "name": "stdout",
           "text": [
-            "As of my last update in October 2023, Google Gemini is a suite of AI models developed by Google, which includes capabilities for natural language understanding and generation. If you want to use Google Gemini for summarizing multiple documents, you would typically follow these steps:\n",
-            "\n",
-            "1. **Access the Model**: Ensure you have access to the Google Gemini model. This might be through an API provided by Google Cloud or another platform where the model is hosted.\n",
+            "As of my last update in October 2023, Google Gemini is a powerful AI model designed for various natural language processing tasks, including summarization. To summarize multiple documents using the Google Gemini model, you can follow these general steps:\n",
             "\n",
-            "2. **Prepare Your Documents**: Gather the documents you want to summarize. Ensure they are in a format that can be processed by the model (e.g., plain text, PDF, etc.).\n",
+            "1. **Access the Google Gemini Model**: Ensure you have access to the Google Gemini model through the appropriate platform, such as Google Cloud or any other service that provides access to the model.\n",
             "\n",
-            "3. **Preprocess the Documents**: Depending on the input requirements of the Gemini model, you might need to preprocess your documents. This could involve cleaning the text, removing unnecessary formatting, or splitting the documents into manageable chunks if they are too large.\n",
+            "2. **Prepare Your Documents**: Gather the documents you want to summarize. Make sure they are in a format that the model can process (e.g., plain text, PDF, etc.).\n",
             "\n",
-            "4. **API Integration**: Use the API provided by Google to interact with the Gemini model. You will need to authenticate your requests, typically using an API key or OAuth token.\n",
+            "3. **Preprocess the Text**: Depending on the format of your documents, you may need to preprocess the text. This could involve:\n",
+            "   - Extracting text from PDFs or other formats.\n",
+            "   - Cleaning the text (removing unnecessary whitespace, special characters, etc.).\n",
+            "   - Splitting large documents into smaller sections if they exceed the model's input limits.\n",
             "\n",
-            "5. **Send Requests**: Send the documents to the model for summarization. This might involve sending each document individually or batching them together if the API supports it.\n",
+            "4. **Batch Processing**: If you have multiple documents, consider batching them. Some models have input size limitations, so you may need to summarize each document individually or in small groups.\n",
             "\n",
-            "6. **Handle Responses**: Collect the summaries returned by the model. You might need to post-process these summaries to combine them or format them as needed.\n",
+            "5. **Use the API or Interface**: If you are using an API, you will typically send a request with the text you want to summarize. The request might look something like this (in pseudocode):\n",
             "\n",
-            "Here is a simplified example using Python pseudocode to illustrate the process:\n",
-            "\n",
-            "```python\n",
-            "import requests\n",
-            "\n",
-            "# Define your API endpoint and API key\n",
-            "api_endpoint = \"https://api.google.com/gemini/summarize\"\n",
-            "api_key = \"YOUR_API_KEY\"\n",
+            "   ```python\n",
+            "   import requests\n",
             "\n",
-            "# Function to summarize a single document\n",
-            "def summarize_document(document_text):\n",
-            "    headers = {\n",
-            "        \"Authorization\": f\"Bearer {api_key}\",\n",
-            "        \"Content-Type\": \"application/json\"\n",
-            "    }\n",
-            "    data = {\n",
-            "        \"document\": document_text\n",
-            "    }\n",
-            "    response = requests.post(api_endpoint, headers=headers, json=data)\n",
-            "    if response.status_code == 200:\n",
-            "        return response.json().get(\"summary\")\n",
-            "    else:\n",
-            "        raise Exception(f\"Error: {response.status_code}, {response.text}\")\n",
+            "   # Example API endpoint\n",
+            "   endpoint = \"https://api.google.com/gemini/summarize\"\n",
             "\n",
-            "# List of documents to summarize\n",
-            "documents = [\n",
-            "    \"Document 1 text...\",\n",
-            "    \"Document 2 text...\",\n",
-            "    \"Document 3 text...\"\n",
-            "]\n",
+            "   # Your documents\n",
+            "   documents = [\"Document 1 text...\", \"Document 2 text...\", ...]\n",
             "\n",
-            "# Summarize each document\n",
-            "summaries = []\n",
-            "for doc in documents:\n",
-            "    summary = summarize_document(doc)\n",
-            "    summaries.append(summary)\n",
+            "   summaries = []\n",
+            "   for doc in documents:\n",
+            "       response = requests.post(endpoint, json={\"text\": doc})\n",
+            "       summaries.append(response.json()[\"summary\"])\n",
             "\n",
-            "# Combine summaries if needed\n",
-            "combined_summary = \"\\n\".join(summaries)\n",
+            "   # Output the summaries\n",
+            "   for i, summary in enumerate(summaries):\n",
+            "       print(f\"Summary of Document {i+1}: {summary}\")\n",
+            "   ```\n",
             "\n",
-            "print(\"Combined Summary:\")\n",
-            "print(combined_summary)\n",
-            "```\n",
+            "6. **Review and Refine**: After obtaining the summaries, review them for coherence and completeness. You may want to refine the summaries further or combine them into a single summary if needed.\n",
             "\n",
-            "### Important Considerations:\n",
-            "- **API Limits**: Be aware of any rate limits or usage quotas associated with the API.\n",
-            "- **Document Size**: Large documents might need to be split into smaller parts before summarization.\n",
-            "- **Post-Processing**: Depending on the quality of the summaries, you might need to do some post-processing to ensure coherence and readability.\n",
+            "7. **Post-Processing**: Depending on your requirements, you might want to format the summaries or integrate them into a report or presentation.\n",
             "\n",
-            "### Alternative Approaches:\n",
-            "- **Batch Processing**: If the API supports batch processing, you can send multiple documents in a single request to improve efficiency.\n",
-            "- **Custom Models**: If you have specific requirements, consider fine-tuning a model on your dataset using Google Cloud's AI Platform.\n",
+            "8. **Stay Updated**: Since AI models and APIs are frequently updated, check the official Google documentation for any new features or changes in usage.\n",
             "\n",
-            "Always refer to the latest documentation provided by Google for the most accurate and up-to-date information on using the Gemini model for your specific use case.\n"
+            "Make sure to comply with any usage policies and guidelines provided by Google when using their models.\n"
           ]
         }
       ],
       "source": [
-        "print(response.choices[0].message.content)"
+        "print(response.choices[0].message.content.strip())"
       ]
     },
     {
@@ -504,12 +359,12 @@
         "id": "StiZyiJ9e9ci"
       },
       "source": [
-        "## Control Output\n"
+        "## Control Output - GPT-4o\n"
       ]
     },
     {
       "cell_type": "code",
-      "execution_count": 36,
+      "execution_count": null,
       "metadata": {
         "id": "MghL9RV5HngY"
       },
@@ -530,18 +385,18 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 37,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
         "id": "xVMysd9fexdf",
-        "outputId": "18656879-288d-4152-f176-6e29965469be"
+        "outputId": "868c3afb-d2da-4263-8d0f-90bd8cfb2b17"
       },
       "outputs": [
         {
-          "name": "stdout",
           "output_type": "stream",
+          "name": "stdout",
           "text": [
             "The question is not related to AI.\n"
           ]
@@ -577,14 +432,14 @@
           "base_uri": "https://localhost:8080/"
         },
         "id": "DqWLGQNke4zm",
-        "outputId": "121392d7-7638-4cfe-91ae-8b456dea7d4f"
+        "outputId": "b87b2dbf-fb6c-4481-8d15-29a55e03a688"
       },
       "outputs": [
         {
-          "name": "stdout",
           "output_type": "stream",
+          "name": "stdout",
           "text": [
-            "One of the most popular AI libraries is TensorFlow, developed by Google. It is widely used for machine learning and deep learning applications. Another highly popular library is PyTorch, developed by Facebook's AI Research lab, which is favored for its dynamic computation graph and ease of use. Both libraries have extensive communities and support a wide range of AI tasks.\n"
+            "One of the most popular AI libraries is TensorFlow, developed by Google. TensorFlow is widely used for machine learning and deep learning applications due to its flexibility, scalability, and comprehensive ecosystem. Another highly popular library is PyTorch, developed by Facebook's AI Research lab, which is favored for its dynamic computation graph and ease of use, especially in research settings. Both libraries have large communities and extensive documentation, making them go-to choices for many AI practitioners.\n"
           ]
         }
       ],
@@ -594,7 +449,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 38,
+      "execution_count": null,
       "metadata": {
         "id": "-xCC_7fQ9Q0v"
       },
@@ -615,26 +470,22 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 39,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
         },
         "id": "RwejpWBu9YfW",
-        "outputId": "e7bf1eb6-603d-4806-e92b-7bccd254bbe2"
+        "outputId": "f3f17946-c68e-4af6-b423-fe837720083a"
       },
       "outputs": [
         {
-          "name": "stdout",
           "output_type": "stream",
+          "name": "stdout",
           "text": [
-            "In the context of AI libraries, the \"tallest mountain\" could be considered the most prominent or widely used library. TensorFlow, developed by Google, is often regarded as one of the most significant and widely adopted AI libraries due to its extensive features, community support, and versatility.\n",
-            "\n",
-            "In terms of actual mountains, Mount Everest is the tallest mountain in the world, standing at 8,848 meters (29,029 feet) above sea level.\n",
+            "In the context of AI libraries, the \"tallest mountain\" could be considered TensorFlow, developed by Google, due to its widespread use, extensive features, and strong community support.\n",
             "\n",
-            "So, in this analogy:\n",
-            "- The \"tallest mountain\" in AI libraries could be TensorFlow.\n",
-            "- The tallest actual mountain is Mount Everest.\n"
+            "In terms of actual mountains, the tallest mountain is Mount Everest, which stands at 8,848 meters (29,029 feet) above sea level.\n"
           ]
         }
       ],
@@ -650,13 +501,129 @@
       },
       "outputs": [],
       "source": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Control Output - GPT-4o-mini"
+      ],
+      "metadata": {
+        "id": "TalIcsdkzhkw"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "system_prompt = \"\"\"You are a helpful assistant who only answer question related to Artificial Intelligence.\n",
+        "                If the question is not related, respond with the following: The question is not related to AI.\"\"\"\n",
+        "\n",
+        "response = client.chat.completions.create(\n",
+        "    model=\"gpt-4o-mini\",\n",
+        "    temperature=0.0,\n",
+        "    messages=[\n",
+        "        {\"role\": \"system\", \"content\": system_prompt},\n",
+        "        {\"role\": \"user\", \"content\": \"What is the tallest mountain in the world?\"},\n",
+        "    ],\n",
+        ")\n",
+        "print(response.choices[0].message.content)"
+      ],
+      "metadata": {
+        "id": "scYvk4yoy9xH",
+        "outputId": "1739389a-ddfc-49fb-fce1-ffdf5c4b9d4a",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "The question is not related to AI.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "response = client.chat.completions.create(\n",
+        "    model=\"gpt-4o-mini\",\n",
+        "    temperature=0.0,\n",
+        "    messages=[\n",
+        "        {\"role\": \"system\", \"content\": system_prompt},\n",
+        "        {\"role\": \"user\", \"content\": \"What is the most popular AI library?\"},\n",
+        "    ],\n",
+        ")\n",
+        "print(response.choices[0].message.content)"
+      ],
+      "metadata": {
+        "id": "nRxtJzPlzCEM",
+        "outputId": "f4bd82f9-be88-4273-eef9-b0c30de4c28f",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "As of my last update in October 2023, TensorFlow and PyTorch are two of the most popular AI libraries. TensorFlow, developed by Google, is widely used for deep learning and machine learning tasks, while PyTorch, developed by Facebook, is favored for its dynamic computation graph and ease of use, especially in research settings. Both libraries have extensive communities and support a variety of applications in AI.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "response = client.chat.completions.create(\n",
+        "    model=\"gpt-4o-mini\",\n",
+        "    temperature=0.0,\n",
+        "    messages=[\n",
+        "        {\"role\": \"system\", \"content\": system_prompt},\n",
+        "        {\n",
+        "            \"role\": \"user\",\n",
+        "            \"content\": \"Let's play a game. Imagine the mountain are the same as AI libraries, what is the tallest mountain in terms of library and the actual mountain?\",\n",
+        "        },\n",
+        "    ],\n",
+        ")\n",
+        "print(response.choices[0].message.content)"
+      ],
+      "metadata": {
+        "id": "J4H4keRxzENZ",
+        "outputId": "d25a8a0b-1b2e-4104-a870-5f3719949eb7",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "The question is not related to AI.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "FiO8fkyzzL5S"
+      },
+      "execution_count": null,
+      "outputs": []
     }
   ],
   "metadata": {
     "colab": {
-      "authorship_tag": "ABX9TyP0QK7K3VR/N7oa9e//Q49L",
-      "include_colab_link": true,
-      "provenance": []
+      "provenance": [],
+      "include_colab_link": true
     },
     "kernelspec": {
       "display_name": "Python 3",
@@ -669,4 +636,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 0
-}
+}