In the dynamic world of software development, efficient coding practices can significantly enhance productivity and project outcomes. Whether you’re an individual developer or part of a collaborative team, optimizing your coding workflow is essential. Enter continue.dev, a robust platform designed to streamline and enhance your development process.

What is Continue.dev?

Continue.dev is a cutting-edge tool that integrates seamlessly into your development environment, providing features that help you maintain focus, manage coding tasks, and enhance your overall productivity. It’s designed to support developers across various programming languages and frameworks, making it a versatile addition to your toolkit.

Getting Started

Getting started with continue.dev is a breeze. Follow these steps to integrate it into your coding workflow:

1. Sign Up: Visit the continue.dev website and create an account.
2. Install the Extension: Download and install the continue.dev extension for your preferred IDE. Here I have used VSCode.

Once installed, you can either sign in with your GitHub account to access the free limited-time offer, or you can install the model locally as shown below.

1. Download and start Ollama
Checking for connection to Ollama… — https://ollama.com/download

2. Download a model for chat
We recommend using llama3, the latest open-source model trained by Meta.

Command: ollama run llama3

3. Download a model for tab autocomplete
We recommend using starcoder2:3b, a state-of-the-art 3B parameter autocomplete model trained by Hugging Face.

Command ollama run starcoder2:3b

4. Download a model for embeddings
We recommend using nomic-embed-text, a 8192 context-length that outperforms OpenAI ada-002 and text-embedding-3-smallon both short and long context tasks.

Command: ollama pull nomic-embed-text

Once it’s done, you can use the continue.dev extension in your IDE as shown below.

You can ask to generate new code and have chat about it.

You can play with some commands like CMD+L and CMD+i to play with it.

Please refer https://www.continue.dev/ for more information.

Conclusion

By integrating continue.dev with VS Code and GitHub, or using local models, you can significantly enhance your coding efficiency, This setup provides a unified solution for managing your development workflow, making it easier to stay productive and deliver high-quality code.

Reference: https://docs.continue.dev/setup/select-provider

Boost Your Coding Efficiency with Continue.dev was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Image Credit: Open AI

OpenAI has introduced GPT-4o, their most advanced AI model yet. Called “GPT-4 Omni,” this model can handle text, images, and audio all at once, making it a huge step forward in AI technology.

GPT-4o is a big leap in AI technology, solving many problems of older models and being more reliable and versatile. For businesses, it means more efficient operations and better customer service. For individuals, it means easier and more helpful interactions with AI, making technology a seamless part of daily life.

What’s New?

Handling Different Types of Input

GPT-4o can process and understand text, audio, images, and video, and it can also create outputs in these formats. For example:

• It can understand a picture, listen to audio, and read text at the same time.
• It can generate responses that include speaking with emotions, singing, or even laughing.

One Model for Everything

Before GPT-4o, different models were used for tasks like transcribing audio and generating text. Now, GPT-4o uses one unified model, which means:

• It can understand and produce more natural audio outputs.
• It can recognize different voices and background sounds in one go.

Better User Experience

Fast and Realistic Responses

GPT-4o responds to audio inputs in about 320 milliseconds, making conversations feel more natural and immediate. This is a big improvement from the previous 5.4 seconds response time.

Free Access for Everyone

OpenAI has made sure that even free users of ChatGPT can access some features of GPT-4o, such as:

• Intelligent conversations.
• Creating and analyzing data charts.
• Interacting with photos.
• Summarizing and analyzing uploaded files.
• Exploring and using GPTs from the GPT Store.
• Personalizing the experience with memory functions.

Technical Improvements

Better Language Processing

GPT-4o uses an improved system for processing text, making it faster and more efficient. This means:

• Quicker responses.
• Less computing power needed.
• More accurate text generation.

Real-World Uses

Customer Service

GPT-4o can improve customer service by giving fast, accurate, and personalized responses, which reduces wait times and boosts satisfaction.

Content Creation

It helps create high-quality content for blogs, articles, and marketing, making it easier for writers.

Healthcare

GPT-4o can help doctors by understanding medical texts and patient data, making diagnoses and treatments more accurate.

Education

It can act as a smart tutor, providing personalized learning and answering students’ questions in real-time.

Ethical and Responsible AI

Reducing Bias

GPT-4o has advanced methods to detect and reduce biases, ensuring fair and unbiased outputs.

Transparency

OpenAI is committed to being transparent about how GPT-4o works, helping users understand its decision-making process and building trust.

Conclusion

GPT-4o is set to change the world of AI with its advanced features and practical applications. Whether you want to improve customer service, create content, or innovate in your field, GPT-4o provides the tools you need to succeed.

Reference

https://openai.com/index/hello-gpt-4o/

“With GPT-4o, OpenAI proves that even AI can multitask better than most humans, effortlessly handling text, images, and audio — all while keeping us wondering if it’s truly intelligent or just really good at faking it.”

Introduction

Generative AI, such as ChatGPT, is gaining popularity among people who aren’t necessarily tech experts. It uses math techniques from statistics, data science, and machine learning that researchers have been refining for a long time.

What is generative AI?

Generative AI is a type of AI that can generate new content. Many people use generative AI in chat applications. One popular example is ChatGPT, a chatbot made by OpenAI.

Generative AI apps understand human language and can respond with text, images, or even computer code.

Large language models(LLMs)

Generative AI applications use large language models (LLMs) that are specialised machine learning models for understanding and processing natural language.

These applications can do tasks like:

1. Text Generation: Creating new sentences or paragraphs based on given prompts or contexts.
2. Language Translation: Translating text from one language to another.
3. Sentiment Analysis: Analyzing the sentiment or emotion expressed in a piece of text.
4. Text Summarization: Generating concise summaries of longer texts.
5. Question Answering: Providing answers to questions based on textual input.

Transformer models

Transformer models are a type of advanced technology used for understanding and working with text. They are really good at figuring out relationships between words in sentences. This helps them understand the meaning of text more effectively, especially over longer distances in a sentence.

The main idea behind transformer models is their ability to pay attention to different parts of a sentence at once, which helps them capture important details and connections between words. This makes them useful for tasks like translating languages, summarizing text, and understanding sentiments in written content.

These models are popular because they can handle large amounts of text data efficiently and can learn complex patterns from this data. They are made up of multiple layers that work together to process and understand text.

Some well-known transformer models you might have heard of include BERT, GPT, and T5, which have been trained on huge amounts of text to become really good at tasks like answering questions or generating text based on given prompts. They have significantly improved our ability to work with and understand language using computers.

Tokenization refers to the process of breaking down a piece of text into smaller units called tokens. These tokens can be words, subwords, or characters, depending on the specific tokenization technique used. Tokenization is a fundamental step in natural language processing (NLP) and is used to prepare text data for further analysis or processing by algorithms. The goal of tokenization is to segment the text into meaningful units that can be easily handled and manipulated by computational systems.

Sentence: “The cat jumped over the fence.”

Tokenization:

Tokens (words): [“The”, “cat”, “jumped”, “over”, “the”, “fence”, “.”]

In this example, the sentence is tokenized into individual words, and each word becomes a token. This tokenized representation allows a computer or AI system to process and understand the sentence more effectively, as it breaks down the text into manageable units for analysis and further processing.

Embeddings refer to the process of representing words or tokens as numerical vectors (arrays of numbers) in a way that captures their semantic meanings and relationships within a dataset. In natural language processing (NLP), word embeddings are used extensively to convert words from a textual format into a format that can be understood and processed by machine learning algorithms.

Let’s use a simple example to illustrate word embeddings:

Suppose we have a small corpus (collection of text) with the following sentences:

“I love apples.”

“I enjoy bananas.”

“I like oranges.”

Step 1: Tokenization

We tokenize each sentence into individual words:

Sentence 1: [“I”, “love”, “apples”, “.”]

Sentence 2: [“I”, “enjoy”, “bananas”, “.”]

Sentence 3: [“I”, “like”, “oranges”, “.”]

Step 2: Vocabulary Creation

We create a vocabulary containing unique words from the corpus:

Vocabulary: [“I”, “love”, “apples”, “enjoy”, “bananas”, “like”, “oranges”, “.”]

Step 3: Assigning Embeddings

We assign numerical vectors (embeddings) to each word in the vocabulary. Let’s represent each word with a 3-dimensional vector for simplicity:

“I”: [0.2, 0.5, -0.1]

“love”: [0.8, 0.3, -0.2]

“apples”: [0.6, 0.1, 0.4]

“enjoy”: [0.7, 0.4, 0.2]

“bananas”: [0.5, 0.6, -0.3]

“like”: [0.3, 0.2, 0.9]

“oranges”: [0.4, 0.7, 0.5]

“.”: [0.0, 0.0, 0.0] (representing punctuation)

Using Embeddings

Now, each word in our sentences can be represented by its embedding vector. For example:

“I love apples.” can be represented as:

[“I”: [0.2, 0.5, -0.1], “love”: [0.8, 0.3, -0.2], “apples”: [0.6, 0.1, 0.4], “.”: [0.0, 0.0, 0.0]]

Word Similarity

We can observe that words with similar meanings or contexts (e.g., “love” and “like”) have embeddings that are closer in value, reflecting their semantic relationships.

These embeddings allow machine learning models to understand and process textual data more effectively by capturing word meanings and relationships based on patterns in the input text. The learned embeddings can be further refined and used as input features for various NLP tasks like sentiment analysis, language translation, and more.

Attention is a critical mechanism enabling AI systems to selectively focus on important information and understand contextual relationships within data. This enhances performance across tasks like language understanding, image analysis, and decision-making.

Example: English to French Translation

Input: “The cat is sitting on the mat.”

Tokenization:

Break down the input sentence into tokens:

Tokens: [“The”, “cat”, “is”, “sitting”, “on”, “the”, “mat”, “.”]

Word Embeddings:

Convert each token into a numerical representation (embedding).

Transformer Encoder:

The transformer’s encoder processes the embedded tokens and computes self-attention scores.

The attention mechanism helps the model focus on relevant words (e.g., “cat”, “sitting”, “mat”) while considering their relationships within the sequence.

Transformer Decoder:

The transformer’s decoder uses the encoder’s output and attends to relevant parts of the input to generate the translated output.

The decoder’s attention mechanism helps align the translated words with the corresponding words in the input, ensuring accurate translation.

Output: “Le chat est assis sur le tapis.”

In this example, the attention mechanism allows the transformer model to focus on key words (like “cat”, “sitting”, “mat”) during translation, understanding their roles and relationships within the input sentence. This selective focus contributes to accurate and contextually relevant translations, demonstrating the importance of attention in General AI for understanding and processing complex data.

“As we continue to explore the capabilities and potential of AI, it’s clear that this technology is reshaping our world and opening up new horizons for innovation and discovery.”

Basics of Generative AI was originally published in Kinomoto AI on Medium, where people are continuing the conversation by highlighting and responding to this story.

Diagrams help us understand complex ideas by showing them visually. But making diagrams can be hard. Luckily, with ChatGPT and draw.io, it's much easier!

Let’s create a sequential diagram illustrating the user authentication flow using ChatGPT and draw.io.

Steps:

Open ChatGPT and provide the following prompt:

“Create PlantUML template for generating a sequence diagram for user authentication”

It will generate something similar to the following. Copy it.

@startuml
actor User
participant "Login Page" as LP
participant "Authentication Service" as AS
database Database

User -> LP: Enter Credentials
activate LP
LP -> AS: Send Credentials
activate AS
AS -> Database: Verify Credentials
activate Database
Database --> AS: Verification Result
deactivate Database
AS --> LP: Authentication Result
deactivate AS
LP --> User: Authentication Status
deactivate LP
@enduml

Now, open Draw.io and navigate to Arrange → Insert → Advanced → PlantUML…

Paste the ChatGPT generated PlantUML code in box.

Click on “Insert” and that’s it. It will generate a sequential diagram for you. You can export(File → Export as → …) it and use in your documentation.

Exercise:

I’ve already provided the prompt to create a class diagram for “inventory management” using ChatGPT and draw.io. Let’s proceed with the task.

“Create PlantUML template for generating a class diagram for inventory management”

It should generate a diagram like the one below.

Conclusion:

The combination of ChatGPT and draw.io offers a seamless way to create diagrams quickly and efficiently. By leveraging ChatGPT’s ability to generate PlantUML code based on simple prompts, users can easily obtain the necessary diagram structure. Then, with draw.io’s integration of PlantUML support, users can effortlessly convert the generated code into a visual representation. This streamlined process simplifies diagram creation, making it accessible to a wide range of users. Whether it’s for illustrating web service communication or login authentication flows or any other requirement like inventory management, this approach provides a convenient solution for visualizing complex concepts and enhancing documentation efforts.

How to Create Diagrams with ChatGPT and draw.io was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction:

In the world of artificial intelligence (AI), the way we ask questions, known as input queries or prompts, is really important. It affects how accurate and relevant the answers from AI systems are. Whether we’re training language models, making chatbots, or doing tasks like understanding natural language, writing good prompts is key to getting the results we want. In this blog, we’ll talk about different ways to write better prompts for AI, and we’ll give examples to show how each technique works.

Clear and Specific Input Queries: It’s really important to be clear and specific when asking questions to AI systems. If the questions are unclear or vague, the AI might get confused and give the wrong answers. Let’s look at an example to understand this better:

Poor Prompt: “Predict.”

Improved Prompt: “Using historical sales data, forecast next month’s revenue for Product X.”

Contextual Relevance in AI Input Queries: Giving extra details in the questions helps AI systems understand what they need to do better. It guides them to give better answers that fit the situation.

Poor Prompt: “Discuss.”

Improved Prompt: “Based on recent customer feedback, analyze sentiment trends towards our new product.”

Open-Ended Input Queries for AI: Instead of asking questions that have only yes or no answers, open-ended questions give AI models more room to provide detailed and thoughtful responses. This helps them understand things better and gives more interesting answers.

Poor Prompt: “Is this article informative?”

Improved Prompt: “Provide an analysis of the key points discussed in this article and evaluate its overall informativeness.”

Varied Input Query Formats: Trying out different ways of asking questions to AI helps them handle different jobs and information better. Mixing up the questions with commands or giving some background info makes AI more flexible and reliable:

Poor Prompt: “Summarize.”

Improved Prompt: “Generate a concise summary of the main themes and findings from this research paper.”

Encouragement and Positivity in AI Input Queries: Keeping a positive and supportive tone when talking to AI helps them feel more comfortable and confident in their responses. When they’re encouraged, AI models are more likely to give clear and confident answers.

Poor Prompt: “Explain why this solution won’t work.”

Improved Prompt: “Propose potential improvements to enhance the effectiveness of this solution.”

These extra things make talking about making prompts for AI even better. It shows that making prompts is complicated and affects how people use the AI, what’s right or wrong, and the impact it has on society.

1. Consistency in Input Queries: Emphasizing the significance of keeping input queries consistent to guarantee that AI-generated responses are uniform and reliable across various interactions and situations.
2. Feedback Mechanisms: Talking about how feedback mechanisms help continuously improve input queries and enhance AI performance by incorporating user input and validation in an iterative process.
3. Ethical Considerations: Dealing with ethical issues in prompt engineering, including avoiding biased language and unintentionally reinforcing harmful stereotypes in input queries.
4. Accessibility Features: Exploring the integration of accessibility features in input queries to accommodate users with disabilities and ensure equitable access to AI technologies.
5. Continuous Learning: Highlighting the importance of continuous learning and adaptation in prompt engineering, wherein AI systems evolve over time based on user feedback and evolving requirements.
6. Collaboration with Domain Experts: Advocating for collaboration between AI developers and domain experts in crafting input queries, leveraging subject matter expertise to enhance the relevance and effectiveness of prompts.

Conclusion:

Asking clear, relevant, and open-ended questions with a positive tone is crucial for optimal AI performance. Effective questioning is essential for improving AI models like chatbots and language programs, enhancing their performance across different tasks and benefiting users.

Mastering the Art of Prompt Engineering: Crafting Engaging and Effective Prompts was originally published in Kinomoto AI on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction:

Fine-tuning AI models is like tweaking a powerful tool to make it work better for specific jobs in fields like medicine and biology. This technique helps scientists understand complicated things in our bodies, find new medicines faster, and tailor treatments to each person. In this blog, we’ll talk about how fine-tuning AI models is used in life sciences, explaining it in simple terms and giving examples to show how it helps researchers make big discoveries and improve people’s health.

Understanding Fine-Tuning:

Fine-tuning AI models is like customizing a tool to fit a particular job. Instead of starting from scratch, which takes a lot of time and effort, we use models that have already learned a lot from previous tasks. These pre-trained models already know a lot about patterns and features in data. Fine-tuning is about making small tweaks to these models so they can better handle new tasks or datasets.

Imagine you have a toolbox with various tools for different jobs. Instead of making a new tool every time you need something done, you might take one of the tools you already have and adjust it slightly to fit the new task better. That’s what fine-tuning is like for AI models.

By fine-tuning, we’re essentially teaching the model to specialize in a new area while still benefiting from what it’s learned before. It’s like giving your tool a new job without starting from scratch, which saves time and effort.

Here are some examples of fine-tuning AI models for the life science domain:

1. Drug Side Effect Prediction: When scientists make new medicines, they need to check if they have any bad side effects. They can use AI to help with this too. By teaching the AI about different drugs and the side effects they can cause, scientists can make it predict which new drugs might have problems. By teaching the AI well and giving it lots of data, they can make sure it’s good at spotting potential risks, which helps keep people safe when they take new medicines.
2. Clinical Trial Optimization: Imagine scientists want to test a new treatment on people to see if it works. This is called a clinical trial. But finding the right people for the trial can be tricky. With AI, scientists can analyze lots of information about patients to find the best candidates for the trial. By using AI to help choose the right patients and plan the trial better, scientists can make sure it runs smoothly and quickly, which helps get new treatments to patients faster.
3. Infectious Disease Forecasting: Health officials want to predict and prevent the spread of diseases like flu or COVID-19. AI can help them do this by analyzing data about how diseases spread. By teaching AI about past outbreaks and how diseases move between people, officials can use it to forecast where outbreaks might happen next. This helps them plan ahead and take actions to stop the spread, like vaccinations or travel restrictions, which protects people from getting sick.
4. Clinical Decision Support: Healthcare providers use clinical decision support systems to assist in diagnosing diseases and planning treatments. AI models can be fine-tuned with patient data, medical guidelines, and clinical research findings to provide personalized recommendations for patient care. By optimizing the AI’s algorithms and training it with real-world patient cases, clinicians can improve diagnostic accuracy, treatment effectiveness, and patient outcomes.
5. Personalized Nutrition Recommendations: Nutritionists can leverage AI models fine-tuned with dietary intake data and individual health metrics to provide personalized nutrition recommendations. By optimizing the AI’s algorithms and training it with dietary guidelines and nutritional research, nutritionists can tailor dietary plans to meet the specific needs and goals of each individual, promoting better health and wellness outcomes.
6. Predictive Modeling for Public Health: Public health agencies can employ AI models fine-tuned with demographic data, health indicators, and environmental factors to develop predictive models for disease outbreaks and public health emergencies. By optimizing the AI’s algorithms and training it with data from past outbreaks and epidemiological studies, policymakers can anticipate disease trends, allocate resources effectively, and implement targeted interventions to mitigate the impact of public health threats.

Conclusion:

Fine-tuning AI models has changed the way we do science in fields like healthcare, drug discovery, biology, and environmental conservation. By making small tweaks and paying close attention to details, scientists can now use AI to solve big problems with more accuracy and flexibility than ever before. This has led to exciting discoveries and improvements in human health and protecting the environment. As we keep learning and using AI in smarter ways, there’s so much more we can do to make life sciences even better.

Introduction:

In today’s digital age, web developers and engineers often find themselves needing to test or share their locally hosted web applications, APIs, or services with others over the internet. However, exposing a local server to the public internet securely can be a daunting task due to security concerns and network configurations. This is where Ngrok comes to the rescue. Ngrok is a powerful tool that simplifies the process of exposing local servers securely, enabling developers to share their work with collaborators or test webhooks and APIs in real-time. In this blog post, we’ll explore the features and capabilities of Ngrok and how it can benefit developers in their day-to-day workflow

What is Ngrok?

Ngrok is a software tool that creates a secure tunnel between a public endpoint and a locally hosted web server or service. It allows developers to expose their local development environment to the internet temporarily, enabling external access to their applications or APIs for testing, collaboration, or demonstration purposes. Ngrok handles the complexities of network configuration and security, making it easy for developers to share their work with others without exposing their local machines to security risks.

Key Features of Ngrok:

1. Expose Local Servers: Ngrok enables developers to expose servers running on their local machines to the internet with a single command. This allows them to share their local development environment with collaborators or test web applications and APIs in real-time.
2. Secure Tunneling: Ngrok establishes a secure tunnel between the local machine and the Ngrok servers using TLS encryption. This ensures that all data transmitted between the local server and the Ngrok servers is encrypted, protecting it from interception or tampering by unauthorized parties.
3. Dynamic URLs: Each time Ngrok is run, it generates a unique URL that serves as a public endpoint for accessing the locally hosted server. This URL can be easily shared with collaborators or clients, allowing them to access the local server over the internet without any additional setup.
4. HTTPS Support: Ngrok supports HTTPS by default, allowing developers to test secure web applications or APIs locally without the need for SSL certificates. This ensures that all communication between the client and the server is encrypted and secure.
5. Traffic Inspection: Ngrok provides a web interface that allows developers to inspect incoming requests and responses, monitor traffic in real-time, and debug issues with their locally hosted services. This makes it easy to identify and troubleshoot any problems that may arise during testing or development.

Installation: https://dashboard.ngrok.com/get-started/setup

To get started with Ngrok, follow these setup points from the official Ngrok documentation:

1. Sign Up for Ngrok Account: Visit the Ngrok website and sign up for an account. You’ll need an account to access the Ngrok dashboard and generate authentication tokens.
2. Download Ngrok: After signing up, download the Ngrok client for your operating system (Windows, macOS, Linux) from the Ngrok website.
3. Installation: Install Ngrok on your local machine by following the installation instructions provided for your operating system.

brew install ngrok/ngrok/ngrok
ngrok config add-authtoken 2eMRCRO5YB636T44rk14pSnV29u_5kvN3wg3T8JPBpk3v3uW3

NOTE: The authtoken mentioned here will not work for you; you will need to use your own unique token.

4. Next, deploy your application online by exposing it at an ephemeral domain forwarding to your upstream service. For instance, if your application is running locally on port 8080, run the command:

ngrok http 5000

Follow Steps from https://dashboard.ngrok.com/get-started/setup as per your system

5. It will open something like below

ngrok                                                                                                                                                                                                 (Ctrl+C to quit)
                                                                                                                                                                                                                      
Take our ngrok in production survey! https://forms.gle/aXdBFdzEd36duddn6                                                                                                                                              
                                                                                                                                                                                                                      
Session Status                online                                                                                                                                                                                  
Account                       Your Name (Plan: Free)                                                                                                                                                                   
Version                       3.8.0                                                                                                                                                                                   
Region                        India (in)                                                                                                                                                                              
Latency                       63ms                                                                                                                                                                                    
Web Interface                 http://127.0.0.1:4040                                                                                                                                                                   
Forwarding                    https://1111-123-123-323-10.ngrok-free.app -> http://localhost:5000                                                                                                                     
                                                                                                                                                                                                                      
Connections                   ttl     opn     rt1     rt5     p50     p90                                                                                                                                             
                              2       0       0.00    0.00    121.64  137.59                                                                                                                                          
                                                                                                                                                                                                                      
HTTP Requests                                                                                                                                                                                                         
-------------

The URL https://1111-123-123-323-10.ngrok-free.app is the public URL generated by Ngrok for your local server. When you run Ngrok, it creates a secure tunnel to expose your locally hosted application to the internet. This generated Ngrok URL serves as the public endpoint through which external users can access your local server.

In this specific case, accessing the Ngrok URL https://1111-123-123-323-10.ngrok-free.app will forward incoming requests to the local server running on http://localhost:5000. This allows anyone, anywhere to access your locally hosted application via the Ngrok URL without being physically connected to your local network.

Conclusion:

Ngrok is a valuable tool for developers who need to expose their local development environment to the internet securely. Its ease of use, powerful features, and robust security make it an essential tool in the toolbox of any web developer or engineer. By simplifying the process of exposing local servers securely, Ngrok empowers developers to collaborate more effectively, test their applications with confidence, and bring their ideas to life faster than ever before.

In summary, Ngrok is a game-changer for developers looking to share their work with others or test web applications and APIs in real-time. With Ngrok, exposing local servers securely has never been easier.

Exploring Ngrok: Exposing Local Servers Securely was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction:

In the realm of software development, Azure DevOps serves as a cornerstone for managing project workflows, including user stories, tasks, and sprints. However, manually retrieving story details from Azure DevOps can be time-consuming and prone to errors. In this blog, we’ll explore how to automate the extraction of story details from Azure DevOps URLs using Python.

Understanding the Challenge:

In agile software development, user stories encapsulate requirements and serve as building blocks for delivering functionality. Often, teams need to extract story details such as title and description from Azure DevOps for various purposes, including documentation, planning, and analysis. Automating this process can enhance productivity and accuracy.

Solution Overview:

Our solution involves leveraging Python along with Azure DevOps REST API to automate the extraction of story details from Azure DevOps URLs. We’ll parse the URL to extract essential components such as the server URL, project name, and story ID. Then, we’ll make an authenticated API request to Azure DevOps to fetch the story details.

Step 1: Parsing the URL:

We start by parsing the provided Azure DevOps URL to extract crucial components using Python’s urllib.parse module. The extracted components include the server URL, organization name, project name, and story ID.

The URL “https://dev.azure.com/your_org/your_project/_workitems/edit/123/" is dissected to extract the server URL (“dev.azure.com”), organization name(“your_org”) project name (“your_project”), and story ID (“123”)

import requests
import urllib.parse

def extract_info_from_url(url):
    # Parse the Azure DevOps URL
    parsed_url = urllib.parse.urlparse(url)
    
    # Extract server name
    server_name = parsed_url.netloc
    
    # Extract path segments
    path_segments = parsed_url.path.strip('/').split('/')
    
    # Extract organization name
    organization_name = path_segments[0]
    
    # Extract project name
    project_name = path_segments[1]
    
    # Extract story ID
    story_id = path_segments[-1]
    
    return server_name, organization_name, project_name, story_id

Step 2: Making the API Request:

Once we have the necessary information extracted from the URL, we construct the API endpoint URL using the server URL, project name, and story ID. We then make a GET request to the Azure DevOps REST API endpoint to fetch the story details. The API request is authenticated using a token retrieved from environment variables.

def get_story_from_url(story_url):
    server_url, organization_name, project_name, story_id = extract_info_from_url(story_url)

    token = "your_token"
    # API endpoint URL
    api_url = f"https://{server_url}/{organization_name}/{project_name}/_apis/wit/workitems/{story_id}?7.1-preview.3"
    # Request headers with authentication

    headers = {
        "Authorization": f"Basic {token}",
        "Content-Type": "application/json"
    }

    try:
        # Make GET request to fetch story details
        response = requests.get(api_url, headers=headers)

        # Check if request was successful (status code 200)
        if response.status_code == 200:
            # Parse JSON response
            story_details = response.json()

            # Extract specific details (for example, title and description)
            title = story_details["fields"]["System.Title"]
            description = story_details["fields"]["System.Description"]

            output_json = {
                "story_title": title,
                "story_desc": description,
                "story_id": story_id
            }

            return output_json
        else:
            print("Failed to fetch story details. Status code:", response.status_code)

    except Exception as e:
        print("An error occurred:", e)
        return e

You have seen we used token in above code. You can generate token by below steps.

1. Sign in to Azure DevOps: Go to the Azure DevOps portal (https://dev.azure.com/) and sign in with your credentials.
2. Navigate to User Settings: Once logged in, click on your profile icon located in the top right corner of the page. From the dropdown menu, select “Security”.
3. Generate PAT: In the Security page, locate the “Personal access tokens” section. Click on the “New Token” button to create a new PAT.
4. Select Scopes: Under “Token scopes”, choose the appropriate scopes based on the level of access your application or script requires. For example, if you’re using the token for read-only access to work items, select the appropriate scope accordingly.
5. Copy Token: Once generated, the token will be displayed on the screen. Make sure to copy the token and securely store it in a safe location. You won’t be able to retrieve it later.

1. Go to terminal and perform echo -n :PAT | base64

Example:

echo -n :y4daplka6d7tnhewsuph2d4tn2qfqdtrveph27ymcrgaekvaj6dq | base64

and it will generate something like

Ond0dGFwfGfddTYfdG5vfHdzdWRwagQ0Y3RgcWZxZHRgdmVwaDIgeW1jcmdhZWt2YWo2ZHE=

And you have to use this type of token in code.

Note: Please note that the token provided in this example is just for demonstration purposes. It won’t work for you. You’ll need to generate your own token following the steps outlined above. Additionally, ensure that you encode your Personal Access Token (PAT) with base64 before using it in your application or script for authentication. This step is crucial for securing your token and ensuring proper authorization when accessing Azure DevOps resources.

Conclusion:

By automating the extraction of story details from Azure DevOps URLs using Python, teams can enhance their productivity and accuracy in managing project work items. This approach not only saves time but also ensures consistency and reliability in retrieving essential information from Azure DevOps, empowering teams to focus on delivering high-quality software solutions.

Code:

import requests
import urllib.parse

def extract_info_from_url(url):
    # Parse the Azure DevOps URL
    parsed_url = urllib.parse.urlparse(url)
    
    # Extract server name
    server_name = parsed_url.netloc
    
    # Extract path segments
    path_segments = parsed_url.path.strip('/').split('/')
    
    # Extract organization name
    organization_name = path_segments[0]
    
    # Extract project name
    project_name = path_segments[1]
    
    # Extract story ID
    story_id = path_segments[-1]
    
    return server_name, organization_name, project_name, story_id

def get_story_from_url(story_url):
    server_url, organization_name, project_name, story_id = extract_info_from_url(story_url)

    token = "your_token"
    # API endpoint URL
    api_url = f"https://{server_url}/{organization_name}/{project_name}/_apis/wit/workitems/{story_id}?7.1-preview.3"
    # Request headers with authentication

    headers = {
        "Authorization": f"Basic {token}",
        "Content-Type": "application/json"
    }

    try:
        # Make GET request to fetch story details
        response = requests.get(api_url, headers=headers)

        # Check if request was successful (status code 200)
        if response.status_code == 200:
            # Parse JSON response
            story_details = response.json()

            # Extract specific details (for example, title and description)
            title = story_details["fields"]["System.Title"]
            description = story_details["fields"]["System.Description"]

            output_json = {
                "story_title": title,
                "story_desc": description,
                "story_id": story_id
            }

            return output_json
        else:
            print("Failed to fetch story details. Status code:", response.status_code)

    except Exception as e:
        print("An error occurred:", e)
        return e
    
print(get_story_from_url("https://dev.azure.com/your_org/your_project/_workitems/edit/your_story_id/"))

Extracting User Story Details from Azure DevOps Python was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction:

In today’s digital age, the internet is a vast repository of information waiting to be explored. However, manually extracting data from websites can be a tedious and time-consuming task. This is where web scraping comes into play. In this guide, we’ll explore the basics of web scraping using Python, a powerful programming language known for its simplicity and versatility.

What is Web Scraping?

Web scraping is the process of extracting data from websites automatically. It involves fetching the HTML content of a web page, parsing it, and extracting the desired information. This information can then be used for various purposes such as data analysis, content aggregation, price monitoring, and more.

Getting Started with Python Web Scraping:

To get started with web scraping in Python, we’ll need to install a few libraries. The two main libraries we’ll be using are Requests and BeautifulSoup.

import requests
from bs4 import BeautifulSoup

Fetching HTML Content from a URL:

The first step in web scraping is fetching the HTML content of a web page. We can use the Requests library to make HTTP requests to the URL and retrieve the HTML content.

def read_data_from_url(url):
    try:
        response = requests.get(url)
        if response.status_code == 200:
            return response.text
        else:
            print(f"Failed to retrieve data from {url}. Status code: {response.status_code}")
            return None
    except Exception as e:
        print(f"An error occurred while retrieving data from {url}: {e}")
        return None

Parsing HTML with BeautifulSoup:

Once we have fetched the HTML content, the next step is to parse it and extract the desired information. BeautifulSoup is a Python library that makes it easy to navigate and search through HTML documents.

# Example usage:
url = "https://wiki.python.org/moin/BeginnersGuide"
data = read_data_from_url(url)
if data:
    soup = BeautifulSoup(data, 'html.parser')
    # Extract text from the HTML
    text = soup.get_text()
    print(text)
else:
    print("Failed to retrieve data from the URL.")

Conclusion:

Web scraping is a powerful technique for extracting data from websites automatically. With Python and libraries like Requests and BeautifulSoup, you can quickly and easily build web scraping applications to gather information from the web. However, it’s essential to use web scraping responsibly and ethically, respecting the terms of service of the websites you scrape. Happy scraping!

A Beginner’s Guide to Web Scraping in Python was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this blog post, we’ll explore how to create a dynamic chat interface that not only responds intelligently but also fetches real-time data from a SQL database. By combining the prowess of OpenAI’s language model and the versatility of SQL databases, we’ll empower our chat interface to provide contextually relevant information on the fly.

Picture this: you’re chatting with a virtual assistant, seeking answers to your queries, and suddenly, it responds not just with pre-programmed responses, but with real-time data fetched from a SQL database. Intrigued? Let’s delve deeper into the fascinating realm of creating a dynamic chat interface that seamlessly integrates with SQL databases.

Preparing the Environment

Before diving into the implementation details, let’s ensure we have all the necessary components set up:

1. OpenAI API Key: Obtain your OpenAI API key and set it as an environment variable using os.environ['OPENAI_API_KEY'].
2. Database Connection: Establish a connection to your SQL Server database using PyODBC. Construct the connection string with your database credentials, server details, and ODBC driver information.

db_connection_string = 'mssql+pyodbc://DBUsername:DBPassword@ServerName:Port/DBName?driver=ODBC+Driver+17+for+SQL+Server'

Constructing the Bridge: OpenAI and SQL Database Integration

Now, let’s bring our chat interface to life by integrating OpenAI’s language model with our SQL database. This synergy allows us to not only respond intelligently but also fetch relevant data on-the-fly. We’ll initialize the OpenAI language model, establish a connection to our SQL database, and create a powerful chain that seamlessly combines the two.

from langchain_community.utilities import SQLDatabase
from langchain_community.llms import OpenAI
from langchain_experimental.sql import SQLDatabaseChain

# Set OpenAI API key
os.environ['OPENAI_API_KEY'] = 'your_openai_api_key'

# Initialize OpenAI language model
llm = OpenAI(temperature=0.2, verbose=True)

# Initialize SQL Database
db = SQLDatabase.from_uri(db_connection_string)

# Create a chain combining the SQL database and OpenAI model
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)

Engaging with the Chat Interface

With our bridge constructed, it’s time to engage in conversation! Imagine typing a query into the chat interface, hitting enter, and witnessing the magic unfold as the virtual assistant responds with contextually relevant information fetched directly from the SQL database. We’ll provide a simple yet effective interface for users to interact with, enhancing their experience and providing them with valuable insights in real-time.

def chat_with_db():
    print("Type 'Q' to quit")

    while True:
        prompt = input("Enter your prompt: ")

        if prompt.lower() == 'Q':
            print('Quitting...')
            break
        else:
            try:
                # Retrieve response from the database chain
                response = db_chain.run(prompt)
                print(response)
            except Exception as e:
                print(e)

# Let's chat!
chat_with_db()

As we conclude our journey, we reflect on the transformative impact of bridging conversations and data. By integrating conversational AI with real-time database interaction, we empower our applications to deliver unparalleled user experiences. Whether it’s providing instant product information, retrieving personalized recommendations, or answering complex queries, the possibilities are endless. So, armed with this newfound knowledge, go forth and revolutionize your applications with the power of conversational data retrieval!

Below is the code consolidated into a single file:

import os
import pyodbc
from langchain_community.utilities import SQLDatabase
from langchain_community.llms import OpenAI
from langchain_experimental.sql import SQLDatabaseChain

# Set OpenAI API key
os.environ['OPENAI_API_KEY'] = 'your_openai_api_key'

# Define SQL database connection string
db_connection_string = 'mssql+pyodbc://DBUsername:DBPassword@ServerName:Port/DBName?driver=ODBC+Driver+17+for+SQL+Server'

# Initialize SQL database
db = SQLDatabase.from_uri(db_connection_string)

# Initialize OpenAI language model
llm = OpenAI(temperature=0.2, verbose=True)

# Create SQL database chain
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)

# Function to chat with SQL database
def chat_with_db():
    print("Type 'Q' to quit")

    while True:
        prompt = input("Enter your prompt: ")

        if prompt.lower() == 'Q':
            print('Quitting...')
            break
        else:
            try:
                print(db_chain.run(prompt))
            except Exception as e:
                print(e)

# Main function
if __name__ == "__main__":
    chat_with_db()

So why wait? Dive into the world of bridging conversations and data, and unlock the potential of your applications today!

Bridging Conversations and Data: Chat Interface with Real-Time Database Interaction was originally published in Dev Genius on Medium, where people are continuing the conversation by highlighting and responding to this story.