Forem: Next Idea Tech

How To Interview Next.js Developers

Zak Elmeghni — Tue, 05 Dec 2023 21:37:15 +0000

When it comes to building modern, efficient web applications, Next.js stands out as a powerful framework. This guide focuses on a critical aspect for any tech team: how to effectively interview Next.js developers. The process involves more than just evaluating technical skills; it’s about uncovering a candidate’s ability to harness Next.js’s features to innovate and […]

The post How To Interview Next.js Developers appeared first on Next Idea Tech Blog.

How Vital Are Cultural Dynamics in Nearshore Outsourcing Success?

Zak Elmeghni — Fri, 01 Dec 2023 06:00:00 +0000

Picture this: It’s 2023, the tech sector is alive with a buzz of Artificial Intelligence innovation and efficiency, driving global collaboration to new heights. Amidst this, nearshore outsourcing has evolved beyond mere cost-saving; it’s now a gateway to a world rich in talent and fresh perspectives. In this challenging economic climate, with inflation and potential […]

The post How Vital Are Cultural Dynamics in Nearshore Outsourcing Success? appeared first on Next Idea Tech Blog.

Pre-Screening Questions For Nearshore Software Developers

Zak Elmeghni — Tue, 28 Nov 2023 20:51:52 +0000

Thinking of hiring nearshore developers? You’re making a smart move! These developers strike the perfect balance in software development: they’re typically in your time zone, culturally aligned, and more cost-effective compared to onshore options. However, selecting the right talent is key. Here’s where effective pre-screening questions for nearshore software developers become essential. This process isn’t […]

The post Pre-Screening Questions For Nearshore Software Developers appeared first on Next Idea Tech Blog.

Nearshore Software Development in Mexico: The Complete Guide 2023

Zak Elmeghni — Sun, 26 Nov 2023 15:32:39 +0000

Mexico, a vibrant and innovative country with a thriving software development industry, has for decades been viewed as a solid nearshore software development destination for tech companies looking to develop pools of talent outside the U.S. Mexico is reaping the benefits not only of geographical proximity and cultural affinity, but also of a growing talent pool of highly skilled software engineers available at knock-down prices.

The post Nearshore Software Development in Mexico: The Complete Guide 2023 appeared first on Next Idea Tech Blog.

Nearshore IT Staff Augmentation: Best Practices for Success

Zak Elmeghni — Sun, 26 Nov 2023 15:27:27 +0000

In this guide, you will learn how IT staff augmentation works and why you should give it some thought. The guide will also examine the advantages and best practices of this innovative strategy.

The post Nearshore IT Staff Augmentation: Best Practices for Success appeared first on Next Idea Tech Blog.

How to Successfully Onboard Nearshore Software Developers Remotely

Zak Elmeghni — Sun, 12 Nov 2023 17:09:18 +0000

Today’s post is all about the onboarding process of nearshore software developers working remotely from a different country. This blog post will provide step-by-step instructions for how to onboard new developers remotely and make them feel like a part of the team even before their first day of work.

The post How to Successfully Onboard Nearshore Software Developers Remotely appeared first on Next Idea Tech Blog.

GPT-4 Vision API Is a Game Changer

Zak Elmeghni — Wed, 08 Nov 2023 20:48:59 +0000

gpt-4-vision-preview is the latest and (arguably) the most powerful model released on November 7 2023 during OpenAI’s DevDay presentation and it has been the talk of social media merely hours after it became available.

Developers have already created apps that actively recognize what’s happening during a web live stream in real-time.

Or this person that incorporated just about every OpenAI API to analyze Messi highlights video using gpt-4-vision-preview model, create voiceover script based on the video frames then generate audio using OpenAI Text-to-Speech

Using gpt-4-vision-preview Model With Python

First install the openai pip module

pip install --upgrade openai #to ensure we are using the latest version

Next, we initialize OpenAI object with our API key and create an instance.

How to obtain your OpenAI API key?

Go to API keys – OpenAI API
Click “Create new secret key”
Provide a name and be sure to copy your new key.

client = OpenAI(api_key="sk_YOUR_OPENAI_KEY")

Making your first call with gpt-4-vision-preview Model

import os
from openai import OpenAI
from dotenv import load_dotenv
import base64
import mimetypes
load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def image_to_base64(image_path):
    # Guess the MIME type of the image
    mime_type, _ = mimetypes.guess_type(image_path)
    
    if not mime_type or not mime_type.startswith('image'):
        raise ValueError("The file type is not recognized as an image")
    
    # Read the image binary data
    with open(image_path, 'rb') as image_file:
        encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
    
    # Format the result with the appropriate prefix
    image_base64 = f"data:{mime_type};base64,{encoded_string}"
    
    return image_base64

base64_string = image_to_base64("image1.jpg")


response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the attached image"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": base64_string,
                        "detail": "low"
                    }
                },
            ],
        }
    ],
    max_tokens=300,
)

print(response.choices[0].message.content)

Stepping Through the Code

The image_to_base64 function is defined to convert an image file to a base64-encoded string. It first checks if the file is an image and then reads and encodes the binary data of the image. Use this option to submit local images.

def image_to_base64(image_path):
    ...

You may also submit image URLs using the below example:

response = client.chat.completions.create(
    model="gpt-4-vision-preview",
    messages=[
        {
            "role": "user",
            "content": [    
                {
                    "type": "text",
                    "text": "What’s in these images? Is there any difference between them?",
                },
                {
                    "type": "image_url",
                    "image_url": "https://www.goodfreephotos.com/albums/other-landscapes/rover-and-landscape-scenery.jpg",
                }
            ],
        }
    ],
    max_tokens=300,
)

The Completion parameters

You may be familiar with the message object If you have used the OpenAI API in the past. With the release of gpt-4-vision-preview model, OpenAI has introduced a new message type; “image_url”.

The url parameter accepts base 64 encoded images or image URLs.

Adjusting the ‘detail‘ parameter in the GPT-4 Vision API affects the resolution and token budget used to interpret images. Setting ‘detail’ to ‘low’ restricts the model to a 512 x 512 pixel, low-resolution version of the image, using 65 tokens. This mode is quicker and more token-efficient, suitable for scenarios where detailed analysis isn’t critical. Opting for ‘high’ engages the high-resolution mode, which initially presents the model with the low-resolution image, followed by high-resolution 512px segments of the image, with each segment allocated a 130-token budget for a thorough examination.

messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the attached image"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": base64_string,
                        "detail": "low"
                    }
                },
            ],
        }
    ]

GPT-4 Vision API Pricing

As shown below, OpenAI prices the vision capability based on image resolution. For example a 512×512 image will cost $0.00255 in “high” detail more, or 0.00085 for “low” model.

GPT-4 Vision API Pricing

This may not seem like a lot but cost does add up when processing hundreds or thousands of images. To control your input image sizes, use the below code to resize them:

Ensure you have the Pillow library installed

pip install Pillow

from PIL import Image
import os

def resize_image(image_path, new_width, new_height):
    with Image.open(image_path) as img:
        # Resize the image
        img = img.resize((new_width, new_height), Image.ANTIALIAS)

        # Save the resized image
        base, ext = os.path.splitext(image_path)
        new_image_path = f"{base}_resized{ext}"
        img.save(new_image_path)

        print(f"Image saved as {new_image_path}")

Real World Use of GPT-4 Vision API: Enhancing Web Experience with a Chrome Extension

Ok so GPT-4 Vision API is cool and all – people have used it to seamlessly create soccer highlight commentary and interact with Webcams but let’s put the gpt-4-vision-preview to the test and see how it fairs with real world problems.

Browser Extension – GPT Vision Assistant

The Chrome extension is designed to harness the GPT-4 Vision API works in a streamlined three-step process:

First, it captures a screenshot of the current tab.

Second, the user is prompted to input a specific question or instruction, articulating what they seek to learn or accomplish with regard to the captured image.

Finally, this input, along with the screenshot, is sent as a request to the OpenAI API. The gpt-4-vision-preview models returns its findings or outputs directly within the extension interface, displaying the results for the user to review. This seamless integration offers a powerful tool for real-time image analysis and interaction, all without leaving the browser tab.

Other Use Cases With GPT-4 Vision API

The GPT-4 Vision API’s capabilities extend beyond simple image recognition and analysis; they open up a world of possibilities for enhancing and streamlining our interactions with digital content. For this purpose, we created a Chrome Extension that leverages this advanced API stands as a testament to its practical utility in everyday web usage. Here are other use cases:

Quality Assurance for Websites: Website developers and QA testers can use the extension to take screenshots of web pages and submit them directly to the GPT-4 Vision API with prompts like “Identify any visual inconsistencies across these screenshots” or “Does this layout comply with web accessibility standards?” The API can analyze the images for color contrast, element alignment, responsive design issues, and more, providing quick feedback that would traditionally require meticulous manual review.
UX/UI Design Feedback: Designers can capture snapshots of their work and ask the model questions such as “What improvements can be made to this user interface to enhance user experience?” or “What are the best practices missing from this design?” This not only speeds up the iterative process of design but also injects an objective, data-driven perspective into creative workflows.
Content Management and Moderation: For content managers and online moderators, the extension could be used to screen website content. By taking screenshots of various posts, images, or comments and querying the GPT-4 Vision API, the system could assist in identifying inappropriate content or copyright issues, streamlining the moderation process.
Educational Content Interaction: Students and educators could use the extension to capture diagrams, equations, or charts from educational websites and ask the model to explain or solve them. This interactive approach could enhance online learning by providing instant assistance and explanations for complex visual information.

GPT-4 Vision API answering a math question

Competitor Analysis: Marketing professionals might employ the extension to capture the layout of competitors’ websites, asking the model to analyze and compare branding consistency, messaging clarity, and call-to-action placements. This competitive intelligence can be invaluable for strategic planning.
Accessibility Auditing: The extension could also be used to assist with ensuring web accessibility. Users could take snapshots of websites and ask the model to check if the images contain proper alt text or if the color schemes used are suitable for color-blind individuals.
Automated Documentation: IT professionals and developers could use the extension to document the behavior of web applications. By taking screenshots and prompting the API to describe the process flow or detect anomalies, they could generate documentation or troubleshooting guides more efficiently.
Code Generation from Designs: A revolutionary use case would be for front-end developers to send UX designs to the OpenAI API and ask it to generate the necessary HTML/CSS/JavaScript code. This could potentially reduce development time by providing a starting point for building out web interfaces.

If interested in the extension or other custom solutions using OpenAI, please email info@nextideated.com

Nearshore MERN Developers

Zak Elmeghni — Fri, 13 Oct 2023 14:45:58 +0000

In the ever evolving world of web development, having a sturdy, scalable, and dynamic web application is like having a superpower. It sets you apart in the bustling online arena. A significant player in this domain is the MERN stack—a blend of MongoDB, Express.js, React.js, and Node.js, making the journey from development to deployment smooth and swift. Now, when the goal is to build such robust applications without burning a hole in your pocket, turning your gaze towards nearshore development realms is a wise move. In this guide, we’ll unearth the steps to hiring MERN stack nearshore developers, ensuring your project is in adept hands from start to finish.

What Is MERN Stack?

The acronym MERN stands for MongoDB, Express.js, React.js, and Node.js, which together form a powerful stack for building top-notch web applications. Now, if you’re on a budget or looking to tap into a diverse talent pool, casting your net towards nearshore waters is a smart move. Let’s venture into the nitty-gritty of hiring MERN stack nearshore developers to propel your project to new heights.

Why MERN Stack?

The MERN Stack is a highly popular choice among developers and businesses looking to build scalable, high-performance web applications. Its component technologies – MongoDB, Express.js, React.js, and Node.js, create a seamless framework that supports the development of robust applications efficiently. For instance, the flexibility and document-based structure of MongoDB make data handling a breeze. Express.js facilitates swift backend development, while React.js is revered for its declarative and efficient JavaScript library for building user interfaces. Lastly, Node.js, with its non-blocking I/O and event-driven architecture, ensures a lightweight and efficient application.

Why Nearshore MERN Developers?

Opting for nearshore MERN developers amalgamates the technical prowess of the MERN stack with the cost-effectiveness and geographical proximity of nearshore outsourcing. Nearshore developers offer a balance between quality and affordability, while their closer location facilitates better communication and collaboration. Moreover, the MERN stack’s popularity in burgeoning tech hubs in nearshore regions ensures a rich talent pool. By hiring nearshore MERN developers, you not only gain access to top-notch technical expertise but also enjoy smoother project management, ultimately steering your web development project towards success.

Understanding Your Project Inside Out

The first step in any recruitment venture is understanding what you need. It’s like going grocery shopping; having a list can be a lifesaver. Delve into your project and carve out a clear, detailed job description. This will act as your compass in the hiring journey, ensuring you find the right fit for your technical and creative needs.

Scoping Out the Right Regions

When we say nearshore, we mean regions close to your country but boasting a thriving tech landscape. Latin America, for instance, is a goldmine of tech talent with developers who are not just skilled but also share a similar time zone with the US. This geographical proximity is what makes nearshore hiring a sweet spot between cost-effectiveness and quality.

Diving into the Nearshore Development Firms

Now, onto the exciting part – scouting for nearshore development firms that specialize in the MERN stack. Dive into some research, look for firms with a trail of successful projects, and sift through client testimonials. Platforms like Clutch.co can be your trusty flashlight in the dark, helping you find firms that resonate with your project’s ethos.

The Technical Rundown

Your nearshore developers need to know their stuff, and a thorough technical evaluation is non-negotiable. Arrange for interviews, ask for portfolios, and if possible, throw in a coding test or two. This stage will help you gauge their command over MERN stack and their problem-solving abilities.

Tuning into the Communication Frequency

Communication is the glue that holds offshore teams together. Ensure that your nearshore developers have a solid grasp of English or any language your team is comfortable with. Moreover, cultural compatibility is a plus as it fosters a smoother collaboration and a harmonious work environment.

Talking Numbers: Compensation

While nearshore hiring is cost-effective, offering a fair compensation is key to attracting and retaining the crème de la crème of MERN stack developers. Do a bit of homework on the prevailing market rates in the nearshore region, and craft a competitive package.

Test the Waters with a Trial Project

Before going full throttle, engage your nearshore team in a small trial project. This is like a test drive, giving you a feel of their technical capabilities, work ethic, and how well they gel with your in-house team.

Cultivating a Long-term Rapport

Building a rapport with your nearshore team isn’t a one-off task but a long-term investment. Regular check-ins, constructive feedback, and celebrating wins, however small, foster a healthy, long-term working relationship.

Navigating the waters of nearshore hiring may seem a tad intimidating initially, but with a methodical approach, it’s a voyage towards a skilled, cost-effective, and harmonious tech team. Your dream MERN stack nearshore team is out there, and with the right approach, you’ll reel them in to kick your project up a notch.

ChatGPT Vision

Zak Elmeghni — Mon, 09 Oct 2023 14:44:19 +0000

OpenAI’s ChatGPT Vision (or GPT-4V) is creating a buzz in the artificial intelligence community. But what is it, and how can you tap into its potential to streamline and automate your business? In this overview, we’ll demystify ChatGPT Vision, discuss its strengths and limitations, and shed light on how to utilize it effectively.

ChatGPT Vision Spotlight

OpenAI is constantly enhancing its chatbot with innovative additions. Understanding ChatGPT Vision Beyond the catchy news titles, ChatGPT Vision isn’t a system that sees as humans do. It’s an AI chatbot equipped with a unique feature: image interpretation. Picture it as a digital era’s visual detective.

Social media has been abuzz about the things you can do with ChatGPT Vision. From creating a web app by merely uploading a Figma screenshot:

To Suggesting recipes by simply snapping a picture of your refrigerator’s content:

How does it do it?

While the headlines might be sensationalized, ChatGPT Vision isn’t a robot that sees like a human.

The underlying technology that allows ChatGPT Vision to process and understand images is built upon a combination of techniques from computer vision, deep learning, and natural language processing. Here’s a technical breakdown:

Computer Vision & Deep Learning:
- Feature Extraction: Images are represented as arrays of pixel values. For an untrained observer, this is just a massive list of numbers, but for a machine learning model, especially convolutional neural networks (CNNs), these pixel values are inputs that can be processed to detect patterns, edges, textures, colors, and other visual features.
- Object Detection: Certain architectures of CNNs, such as YOLO (You Only Look Once) and SSD (Single Shot Multibox Detector), can identify multiple objects within an image by drawing bounding boxes around them. This is more than just feature extraction; it’s recognizing and localizing objects.
- Image Classification: Models like ResNet, VGG, and MobileNet can label an entire image based on its primary content. For instance, recognizing an image as containing a cat or a dog.
- Semantic Segmentation: Some models can classify each pixel of an image into a category, which helps in understanding the image at a very granular level.
Optical Character Recognition (OCR):
- If there’s a need to extract text from images, OCR technologies come into play. OCR converts images of typed or handwritten text into machine-encoded text. Under the hood, OCR models might also use deep learning, but their training and architecture are specialized for recognizing characters and words in a variety of fonts and backgrounds.
- There are popular OCR libraries like Tesseract which are widely used, but there are also deep learning-based methods that can achieve even better accuracy, especially in challenging conditions.
Combining Vision and Language:
- Once objects, features, or text are extracted from an image, it’s often important to combine this information with natural language processing (NLP) techniques. This helps in generating descriptions, answering questions about the image, or even translating the detected text.
- Models like OpenAI’s CLIP (Contrastive Language–Image Pre-training) are trained on a large number of images and their descriptions, allowing them to understand images in the context of natural language queries.
Differentiating Between Text, Pixels, and Visual Objects:
- At the basic level, everything in an image is just pixels. However, deep learning models can learn the patterns that differentiate objects from the background, text from non-text regions, and so on.
- For instance, the patterns of pixels that typically represent text (straight lines, curves of letters, spacing between characters) are different from the patterns of pixels that represent natural objects. Models trained for OCR will thus specialize in recognizing these text-like patterns.

How can ChatGPT Vision help your business?

For tech businesses, especially those in the SaaS, Digital Business world, GPT4-V can offer a range of opportunities to innovate and enhance their offerings. Here’s how they can leverage these capabilities:

Customer Support & Troubleshooting:
- Users can send screenshots or photos of issues they’re encountering. ChatGPT Vision can recognize common errors, interface elements, or problematic configurations and guide users toward a solution.
UI/UX Feedback:
- Founders can gather visual feedback on their software interfaces. Users can submit screenshots, and the chatbot can analyze common points of confusion or suggest design improvements based on patterns it recognizes.
Documentation Assistance:
- Instead of scrolling through long FAQs, users can snap a picture of the part of the software they’re struggling with. ChatGPT Vision can then provide relevant documentation or tutorial links.
Feature Onboarding:
- As new features are rolled out, users can interact with the chatbot using screenshots to get personalized walkthroughs, ensuring they understand and adopt new functionalities.
Competitor Analysis:
- By feeding the chatbot screenshots of competitor software, SaaS founders can get insights into design trends, feature commonalities, or potential areas for differentiation.

The Impact on Digital Businesses

It’s tough to predict what’s just a passing trend in AI and what’s here to stay. While some ChatGPT updates got a lot of buzz but then faded, things look different with the latest visual features.

OpenAI is working on better image tools, like an updated Dall-E 3, and they’re planning to add it to ChatGPT. And with companies like Google possibly adding visual features to their chatbots, this might not just be a fleeting trend. It feels like we’re at the beginning of something big in how businesses use AI.

ChatGPT With SQL Database using LangChain

Zak Elmeghni — Thu, 05 Oct 2023 13:10:46 +0000

Introduction to LangChain

LangChain is a revolutionary technology that serves as a bridge between natural language processing (NLP), ChatGPT and databases. It allows users to interact with their databases using natural language, making it easier to retrieve, manipulate, and manage data without the need for intricate SQL queries. LangChain leverages advanced NLP techniques to understand user queries and translate them into SQL, enabling seamless communication with databases.

Why LangChain?

As we mentioned in this article, LangChain fills a crucial need in the realm of Large Language Models (LLMs). While LLMs excel at a wide range of tasks, they may fall short when it comes to providing specific answers or deep domain expertise. To address this limitation, LangChain adds data-awareness and agentic capabilities to LLMs, allowing applications to connect to external data sources and engage in interactive, context-aware interactions. This integration empowers developers to build more powerful and specialized language model applications that can provide targeted and nuanced responses, bridging the gap between LLMs and domain-specific knowledge requirements.

How LangChain Works with SQL Databases

LangChain can be integrated with SQL databases to facilitate natural language interactions. Users can ask questions or make requests in plain English, and LangChain translates these into the corresponding SQL queries. This interaction enables users, even those without technical expertise in SQL, to access and manage their database information efficiently.

Step 1: Installing Dependencies

Start by creating and activating a virtual environment. Execute the following commands:

python -m venv venv
source venv/bin/activate # for Ubuntu
venv/Scripts/activate # for Windows

Once the virtual environment is activated, install the necessary packages:

pip install langchain langchain-experimental openai

Step 2: OpenAI API Key

LangChain is compatible with several LLMs, but using OpenAI models often yields better results.

To use LangChain with OpenAI models, you need an OpenAI key. Follow the steps below to create a new OpenAI key:

Visit platform.openai.com.
Click on your name or icon, located on the top right corner, and select “View API Keys” or follow this link.
Click on the “Create new secret key” button to generate a new OpenAI key.
We will use the API key in the next segment where we will write chat function.

Step 3: Creating a Python Script with LangChain + ChatGPT

Create a new Python file named langchain_sql_chat.py and add the following code to it:

import os
from langchain.utilities import SQLDatabase
from langchain.llms import OpenAI
from langchain_experimental.sql import SQLDatabaseChain

os.environ['OPENAI_API_KEY'] = 'OPENAI API KEY from Step 2'

db = SQLDatabase.from_uri("mysql://username:password@hostname/database_name")

llm = OpenAI(temperature=1, verbose=True)
db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)

def chat_with_sql():
    print("Type 'exit' to quit")

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

        if prompt.lower() == 'exit':
            print('Exiting...')
            break
        else:
            try:

                print(db_chain.run(prompt))
            except Exception as e:
                print(e)

chat_with_sql()

The above code connects to a SQL database defined by connection string mysql://username:password@hostname/database_name

Ensure that you replace username, password, hostname, and database_name with your actual database credentials and details.

The SQL Database

For the purpose of this article, we are using an inventory database, which is a structured repository designed to manage various aspects of stock levels in a retail environment. This database contains several tables, each serving a specific purpose in inventory management. The products table holds essential information about the items, including product ID, name, description, and price.

products.sql

CREATE TABLE products (
    product_id INT PRIMARY KEY,
    product_name VARCHAR(255) NOT NULL,
    description TEXT,
    price DECIMAL(10, 2) NOT NULL CHECK (price >= 0)
);

suppliers.sql

CREATE TABLE suppliers (
    supplier_id INT PRIMARY KEY,
    supplier_name VARCHAR(255) NOT NULL,
    contact_name VARCHAR(255),
    contact_email VARCHAR(255),
    contact_phone VARCHAR(20)
);

inventory.sql

CREATE TABLE inventory (
    inventory_id INT PRIMARY KEY,
    product_id INT,
    supplier_id INT,
    quantity_in_stock INT NOT NULL CHECK (quantity_in_stock >= 0),
    last_stocked_date DATE,
    FOREIGN KEY (product_id) REFERENCES products(product_id),
    FOREIGN KEY (supplier_id) REFERENCES suppliers(supplier_id)
);

Chat with your data using LangChain + ChatGPT

Now that we have our code ready, run the function using:


python langchain_sql_chat.py

The following prompt should appear

Enter a prompt:

To query the database, ask questions such as “How many units of Product X are in stock“

You should see the following:

Type 'exit' to quit
> Entering new SQLDatabaseChain chain...
    How many units of Product X are in stock?
    SQLQuery:SELECT quantity_in_stock FROM "inventory" WHERE product_id = (SELECT product_id FROM "products" WHERE product_name = 'Product X');
    SQLResult: [(15,)]
    Answer:There are 15 units of Product X in stock.
    > Finished chain.

More complex questions

Let’s ask a question that requires a JOIN statement.

Type 'exit' to quit
> Entering new SQLDatabaseChain chain...
    List all products with less than 10 units in stock.
    SQLQuery:SELECT product_name FROM "products" INNER JOIN "inventory" ON products.product_id = inventory.product_id WHERE quantity_in_stock < 10;
    SQLResult: [('Product A',), ('Product B',), ('Product C',)]
    Answer:Products with less than 10 units in stock are Product A, Product B, and Product C.
    > Finished chain.

LangChain was able to deduce that a “JOIN” statement is required in order to satisfy the prompt.

Conclusion

This guide serves as a foundational step to get started with LangChain and Database implementations, enabling you to interact conversationally with your SQL database. By following the outlined steps, you can leverage the power of Langchain to make database interactions more user-friendly and efficient.

Whether you are managing an inventory database or any other type of database, LangChain, combined with GPT, translates your natural language inquiries into precise SQL queries, allowing for seamless communication with your database.

Embark on your software development adventure with Next Idea Tech! As a distinguished software development and nearshore outsourcing firm, we deliver a plethora of business solutions tailored to your needs. We are here to connect you with the cream of the crop in talent for your projects. Our mission is to pair you with seasoned professionals who are experts in their fields. We boast a team of experienced developers, testers, project managers, and marketing specialists, all poised to contribute to your success!

Let’s discuss your business aspirations! We extend complimentary consultations to understand your project better.

Which Countries Have the Best Software Developers in Latin America

Zak Elmeghni — Thu, 31 Aug 2023 16:15:53 +0000

In a market where demand exceeds supply and rates are rising, this article helps answer a question being asked across the North American tech industry: where are the best developers in Latin America and what are their rates? This article will give you a summary of these questions and tell you why the Latin American territory has the most coveted software developers.

The post Which Countries Have the Best Software Developers in Latin America appeared first on Next Idea Tech Blog.

ChatGPT Chatbot For Google Docs

Zak Elmeghni — Fri, 23 Jun 2023 16:48:28 +0000

ChatGPT has certainly carved a niche for itself in the realm of AI, but its closed-source nature and inability to access external datasets can sometimes limit its use, especially when it comes to personal documents. But what if you could leverage the capabilities of Python, Google Docs, ChatGPT, and LangChain to create your own advanced “Google Docs ChatGPT chatbot”?

Imagine having a Google Docs ChatGPT chatbot that can interact directly with files stored in your Google Drive.

So, whether you’re a developer, a tech enthusiast, or someone who just wants to streamline their work on Google Docs, stick around. This guide on creating your own “Google Docs ChatGPT chatbot” might just be the solution you’ve been seeking!

This article will cover:

What is LangChain?
Openai / ChatGPT Limitation
Why Use a Google Docs ChatGPT Chatbot?
LangChain Document Loaders
Setting up Google API Credentials
Step by step: How to build Google Docs ChatGPT Chatbot

What is LangChain?

LangChain is an innovative framework that is designed around the use of Large Language Models (LLMs). It was created by Harrison Chase and first introduced in late 2022. This powerful tool has grown popular due to the rise of generative AI and advancements in LLMs, like Google’s LaMDA chatbot, BLOOM, and OpenAI’s GPT-3.5 models.

What makes LangChain unique is its ability to ‘chain’ together various components, thus enabling advanced applications of LLMs. These applications range from chatbots and generative question-answering (GQA) to summarization tasks and more.

LangChain incorporates multiple key components in its structure. It uses ‘Prompt templates‘ which are predefined templates that can be adjusted to suit various types of prompts. These include prompts for chatbot-like interactions, question-answering in the style of ‘Explain it Like I’m Five’, and more.

Another critical part of LangChain is the LLMs themselves, including models like GPT-3 and BLOOM. These large language models form the core of LangChain’s functionality.

Then we have ‘Agents’, which use LLMs to determine the appropriate actions to take. They leverage tools like web search or calculators and wrap them into a logical operation loop.

Openai / ChatGPT Limitation

OpenAI’s API and ChatGPT have a key drawback: they struggle with large custom datasets. The max_token limit means you can’t put a lot of data into the context window. Plus, they’re not set up to handle individual document collections well. But LangChain helps to solve this. It uses Document Loaders to import and adapt data, so it works well with ChatGPT. This allows developers to make better use of their unique datasets with large language models.

Why Use a Google Docs ChatGPT Chatbot?

Why should you build a “Google Docs ChatGPT Chatbot”? The answer is simple – it provides you with the ability to converse directly with your Google Docs documents. By harnessing the capabilities of ChatGPT, langchain, and Python, this chatbot transforms your documents into an interactive platform. Imagine needing information about a company process or having questions about onboarding – with this chatbot, the answers are just a conversation away. It’s not just about accessing information, it’s about streamlining communication and making knowledge sharing more efficient.

LangChain Document Loaders

LangChain’s document loaders provide a robust solution for importing data from various sources and transforming it into Document objects. A Document object essentially contains a piece of text along with any associated metadata. The power of LangChain lies in its variety of document loaders. These include the CSV | 🦜️🔗 Langchain for working with CSV files, PDFLoader for handling PDF documents, a File Directory loader for importing data from a file system, and a JSON loader for processing JSON data.

loader = GoogleDriveLoader(
        credentials_path=CLIENT_SECRET_FILE,
        token_path=TOKEN_FILE,
        folder_id=GOOGLE_DRIVER_FOLDER_ID,
        recursive=False,
        file_types=["sheet", "document", "pdf"],
    )
return loader.load()

What’s truly useful about these document loaders is their ‘load’ method. It extracts data from a configured source and turns it into Document objects. For more efficient memory utilization, LangChain also supports ‘lazy load’. This feature progressively loads data into memory as and when required, rather than loading it all at once. This functionality is not just limited to standard text files. For instance, LangChain can load the text contents of a web page or even fetch and process the transcript of a YouTube video, expanding the scope of data sources you can tap into.

Setting up Google API Credentials

In order to build our Google Docs ChatGPT chatbot, we will use GoogleDriveLoader document loader.

The GoogleDriveLoader is a document loader that allows you to ingest data from Google Docs into your LangChain project. It can load from a list of Google Docs document IDs or a folder ID.

To use the GoogleDriveLoader, you need to have a Google Cloud project and enable the Google Drive API. You also need to authorize credentials for a desktop app and install the necessary Python packages. Once you have set up the loader, you can use it to fetch data from Google Docs and integrate it into your LangChain project.

Setting up your Google Drive API credentials is an essential step when you’re looking to leverage Google Drive functionalities in your application. Let’s break it down step by step.

Creating a new Google Cloud Project: Start by visiting your Google Cloud Console at https://console.cloud.google.com. If you’re not already signed into your Google account, you’ll be prompted to do so. Once in the Console, you can create a new project by clicking on the project dropdown (a triangle next to your Project Name) in the top left corner. A panel will slide open with a list of your projects and a ‘NEW PROJECT’ button at the top. Click on it, name your new project, and create it.

Setting up Google Cloud API for ChatGPT Chatbot

Enabling the Google Drive API: After creating your project, you need to enable the Google Drive API for it. This can be done by visiting the ‘Library’ in the left sidebar. Here, search for ‘Google Drive API’, click on the resulting option, and then click ‘Enable’. If you don’t see the ‘Enable’ button immediately, you may need to refresh the page or navigate back to it once your new project is fully set up.

Setting up Google API Credentials: This process involves four main steps:
- Authorize credentials for a desktop app: In the Google Cloud Console, navigate to ‘Credentials’ under ‘APIs & Services’. Click on ‘Create Credentials’ and select ‘OAuth client ID’. In the ‘Application type’, choose ‘Desktop app’. Enter a name for your OAuth client ID and click ‘Create’.
- Download your credentials: After creating, download the credentials by clicking on the download icon (a down arrow) next to the client ID you’ve just created. This will download a JSON file, such as client_secret_23429870XXXXXXXXXXXXXX.json.
- Configure your consent screen: Go to ‘OAuth consent screen’ under ‘APIs & Services’ and fill out the necessary details. This includes the app name, user support email, developer contact information, and more. This is the information users will see when your app requests access to their data.
- Add yourself as a test user: On the same ‘OAuth consent screen’, scroll down to the ‘Test users’ section and click on ‘Add Users’. Enter your email and save. This is especially important when your app is in a testing phase.
Storing your Credentials: The credentials you downloaded come in a JSON file, which by default, LangChain expects to be stored at ~/.credentials/credentials.json. However for the sake of this project, we will place the credentials.json in the project root directory and point it using the GOOGLE_APPLICATION_CREDENTIALS variable.

Step by step: How to build Google Docs ChatGPT chatbot

Installing Python dependencies

pip install openai
pip install langchain
pip install openai
pip install chromadb
pip install PyPDF2
pip install sentence_transformers
pip install torch
pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib

Note: when running the application, you may receive an error message AssertionError: Torch not compiled with CUDA enabled.

This is because the code relies on torch which needs to be installed as follows in order to support CUDA

pip uninstall torch
pip cache purge
pip install torch -f https://download.pytorch.org/whl/torch_stable.html

Code Walkthrough

load_documents()

def load_documents():
    loader = GoogleDriveLoader(
        credentials_path=CLIENT_SECRET_FILE,
        token_path=TOKEN_FILE,
        folder_id=GOOGLE_DRIVER_FOLDER_ID,
        recursive=False,
        file_types=["sheet", "document", "pdf"],
    )
    return loader.load()

The load_documents() function is used to load documents from a specific Google Drive folder. The GoogleDriveLoader class from the langchain.document_loaders module is instantiated with several arguments: a path to the client secret file for authentication (CLIENT_SECRET_FILE), a path to the token file (TOKEN_FILE), and the ID of the Google Drive folder containing the documents (GOOGLE_DRIVER_FOLDER_ID). The recursive argument is set to False, which means the loader will not look for files in sub-folders of the specified folder. The file_types argument lists the types of files to load from the folder (in this case, Google Sheets, Google Docs, and PDF files). The function returns the loaded documents.
file_types: denotes the file types you want to index. “document” corresponds to “Google Docs” file type. GoogleDriveLoader will not index “.doc” or “.docx” files that you manually uploaded to the target folder.

Getting Google Drive Folder_ID

Getting the ID of a Google Drive folder is quite straightforward. Follow these steps:

First, you’ll need to open your Google Drive in a web browser. This can be done by visiting the URL: https://drive.google.com.
Navigate to the folder whose ID you want to retrieve.
Once you’re inside the folder, look at the URL in your web browser’s address bar. It should look something like this: https://drive.google.com/drive/u/0/folders/1A2B3CDEFGH456I7J89K
The part of the URL after ‘folders/’ is the ID of the Google Drive folder. In the example above, the folder ID is 1A2B3CDEFGH456I7J89K.
Copy this ID and use it for “GOOGLE_DRIVER_FOLDER_ID” variable in your code.

Getting your Google Drive Folder ID

split_documents(docs)

def split_documents(docs):
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=4000, chunk_overlap=0, separators=[" ", ",", "\n"])
    return text_splitter.split_documents(docs)

The split_documents(docs) function is used to split the loaded documents into chunks. The RecursiveCharacterTextSplitter class from the langchain.text_splitter module is instantiated with specified arguments: chunk_size=4000 indicating that each chunk will contain approximately 4000 characters, chunk_overlap=0 indicating that there will be no overlapping characters between the chunks, and separators=[" ", ",", "\n"] indicating the preferred points (space, comma, or newline) at which to split the text. The function returns the document text split into chunks.

generate_embeddings()

def generate_embeddings():
    return HuggingFaceEmbeddings(model_name=HUGGINGFACE_MODEL, model_kwargs=MODEL_KWARGS)

The generate_embeddings() function creates an instance of the HuggingFaceEmbeddings class from the langchain.embeddings module. The instance is created with the specified model name (HUGGINGFACE_MODEL) and additional keyword arguments (MODEL_KWARGS), which in this case is to specify that the model should run on a CUDA-enabled GPU. The function returns the HuggingFace embeddings generator.

create_chroma_db(texts, embeddings)

def create_chroma_db(texts, embeddings):
    if not os.path.exists(PERSIST_DIRECTORY):
        return Chroma.from_documents(texts, embeddings, persist_directory=PERSIST_DIRECTORY)
    else:
        return Chroma(embedding_function=embeddings, persist_directory=PERSIST_DIRECTORY)

The create_chroma_db(texts, embeddings) function creates a Chroma database that stores the embeddings for the chunks of text. The Chroma class is from the langchain.vectorstores module. If the specified persistence directory (PERSIST_DIRECTORY) does not exist, it creates a new Chroma database using the texts and their corresponding embeddings. If the directory already exists, it assumes the Chroma database has already been created, and just loads it using the Chroma() constructor, which needs the embeddings function and the persistence directory as arguments.

create_retriever(db)

def create_retriever(db):
    return db.as_retriever(search_kwargs={"k": RETRIEVER_K_ARG})

The create_retriever(db) function creates a retriever object from the Chroma database. The retriever will be used to find the most relevant chunks of text based on a given query. The .as_retriever() method of the Chroma database object is used to create the retriever. The search_kwargs parameter is used to configure the search behavior of the retriever; here, it sets the “k” parameter, which determines the number of top results to retrieve.

create_index(llm, retriever)

def create_index(llm, retriever):
    return RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever)

The create_index(llm, retriever) function uses the RetrievalQA class from the langchain.chains module to create an index that combines a language model (llm) and a retriever. The from_chain_type() static method is used to create the index, with “default” as the chain type, and the provided language model and retriever as arguments.

create_llm()

def create_llm():
    return ChatOpenAI(temperature=0, model_name=OPENA_AI_MODEL)

The create_llm() function is used to instantiate an instance of the ChatOpenAI class from the langchain.chat_models module, which represents a language model. The temperature parameter is set to 0, indicating that the model’s outputs will be deterministic (i.e., always choosing the most probable next word). The model_name is set to OPENA_AI_MODEL, a constant that refers to a specific version of the OpenAI model to use (in this case, “gpt-4-0314”). The function returns the instantiated language model.

main()

def main():
    docs = load_documents()
    texts = split_documents(docs)
    embeddings = generate_embeddings()
    db = create_chroma_db(texts, embeddings)
    retriever = create_retriever(db)
    llm = create_llm()
    qa = create_index(llm, retriever)

    while True:
        query = input("> ")
        if query.lower() == "exit":
            exit()
        answer = qa({"query": f"### Instructions. {PRE_PROMPT_INSTRUCTIONS} ###Prompt {query}"})
        print(answer['result'])

if __name__ == "__main__":
    main()

The main() function orchestrates the entire process of loading, processing, and querying documents.

The function then enters an infinite loop, where it repeatedly asks the user for a query (with input("> ")). The loop continues until the user enters “exit”, at which point the program exits.
If the input isn’t “exit”, the function treats the input as a query and passes it to the qa object (the index created earlier), which is responsible for producing a response. This response is then printed out.

First run
The first time you correctly execute your program, it will automatically open a web browser prompting you to sign in to your Google account. You should log in with the account that you previously set up as a test user during the preparation stage. Once you’ve successfully authenticated your account, the application will quietly generate a token.json file and download it.

Note: the token file name is whatever value you specify in TOKEN_FILE variable.

This file will contain the necessary tokens to access your Google account and it will be used for future sessions, eliminating the need for you to manually log in each time you run the program.

Conclusion

This kind of chatbot has a wide variety of use-cases, especially where dealing with large amounts of text data is involved. Here are a few examples:

Research: If you’re a researcher dealing with a large corpus of articles, papers, or reports, this program can help you find relevant information quickly. Instead of manually reading through each document, you can query the system and get the information you need.
Legal Work: In legal professions, there’s often a need to comb through large volumes of legal documents, cases, or laws to find relevant references or precedents. This system could drastically reduce the time spent on such tasks.
Customer Support: This could be used in a company’s customer support to quickly find answers to customer queries based on a large database of product manuals, previous support tickets, and other documentation.
Education: Teachers and students could use this to quickly find relevant study material from a large corpus of textbooks, articles, and other educational resources.
Content Creation: Writers and content creators could use it to quickly find inspiration, references, or background information from a vast collection of documents.
Business Intelligence: Companies could use this system to extract insights from a vast amount of business reports, meeting minutes, or emails.
Healthcare: Medical practitioners can use it to search through a large collection of medical literature, case studies, research papers, and find treatment options, diagnose diseases, etc.

You can find the code in this github repository