Is Phind AI the Ultimate Coding Search Engine?

Have you ever gotten stuck coding and wished you had a super-powered teammate who could answer your questions and even write some code alongside you? Well, buckle up, because Phind AI might be your new best friend!

Phind is an AI tool specifically designed to help developers. It uses massive language models, like Phind-70B or the supercharged Phind-CodeLlama-34B-v2, to understand your code and answer your questions in a real coding context. Think of it as a coding buddy who’s always there to lend a hand (or a line of code!).

Whether you’re stuck on a tricky bug or need help brainstorming a new solution, Phind can be a valuable asset in your development toolbox. Stay tuned, because I’m putting Phind to the test to see how it tackles a real-world coding challenge!

Unveiling the Power of Phind AI: Features & Benefits for Developers

Alright coders, so Phind throws around terms like “conversational search” and “code analysis ninja” – but what does that actually mean for us? Can Phind, with its arsenal of powerful models including Phind-70B and Phind-CodeLlama-34B-v2, truly become our coding BFF, or is it all smoke and mirrors? Let’s dissect the features that might actually make Phind a valuable tool in our arsenal:

1. Natural Language Questions: Finally, ditching those cryptic search terms! Phind lets you ask questions in plain English, which sounds great in theory. But the real question is: how well does it understand your intent?
2. Contextual Recall: Remembering your conversation history is a cool feature. It could save time if you don’t have to repeat yourself. But will Phind actually make the connection between your questions, or will it just give generic responses?
3. Code Analysis with a Caveat: Phind analyzing your code for bugs sounds promising – like having a second pair of eyes. But can we trust its suggestions? We’ll need to see how accurate Phind’s analysis actually is.
4. Learning Assistant Potential: Phind surfacing relevant learning resources is handy. But is it better than a good developer friend or a curated online learning platform? We’ll need to see how well Phind tailors its suggestions to your specific needs.

These are the features we’ll be putting to the test. In the next section, we’ll dive into building a real-world project with Phind. We’ll see if these features truly live up to the hype, or if they’re just fancy marketing speak.

Working with Phind AI: Two Modes for Developers

Phind caters to developers in two primary ways:

• Web Interface: This user-friendly option allows you to interact with Phind directly through your web browser. It utilizes a conversational search interface, making it perfect for quick coding inquiries, exploring solutions, and leveraging Phind’s learning assistant features. The web interface itself offers functionalities through two key modes: Chat and Search.
• Code Integration (Optional): For a more streamlined workflow, Phind offers integration options for your development environment (e.g., VS Code extension). This enables you to access Phind’s functionalities directly within your code editor, such as code analysis and conversational search for specific coding problems you encounter while developing.

Chat Mode vs. Search Mode: Tailoring Phind to Your Workflow

While both reside within the web interface, Chat and Search modes cater to distinct development needs:

• Chat Mode: Designed for building projects from start to finish, Chat mode excels at handling large chunks of code. Imagine you’re building a complex algorithm. Chat mode would be ideal here. You can paste your code snippets, explain your goals, and receive suggestions or identify potential issues as you progress. Unlike Search mode, Chat mode can ask clarifying questions to understand your intent before proceeding with searching and generating code. This makes it a valuable tool for iterative development.
• Search Mode: This mode is your go-to option for quick questions, specific code problems, or exploration. Phind’s conversational search capabilities shine here, allowing you to ask questions in plain English and receive relevant responses. Think you’re stuck on a specific syntax error or need a quick solution for a particular coding task? Search mode would be your best bet.

Creating a Real Life Application with Phind

We will try to build a simple Appointment Application backend from scratch. We shall use the following openapi.yaml file as the starting point. For IDE, we shall use Microsoft Visual Studio Code. Let’s see if Phind lives up to its promise.

openapi: 3.0.0
info:
  title: Appointment Booking API
  version: 1.0.0

servers:
  - url: /api  # Replace with your actual server url

paths:
  /appointments:
    get:
      summary: List all appointments
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Appointment'
    post:
      summary: Create a new appointment
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/Appointment'
      responses:
        '201':
          description: Created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Appointment'
  /appointments/{id}:
    get:
      summary: Get details of a specific appointment
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Appointment'
        '404':
          description: Not Found

components:
  schemas:
    Appointment:
      type: object
      properties:
        id:
          type: string
          format: uuid  # Replace with your preferred ID format
        user_id:
          type: string
        service_id:
          type: string
        datetime:
          type: string
          format: date-time  # Example format, adjust based on your needs

I kept the definitions simple as we want to see if Phind can build the basic application without any hiccups. We have also installed Phind’s Visual Studio Extension plugin to ease the development process.

Telling Phind what to do?

We used Phind’s Chat Console on their website to start the conversation.

Here’s what we asked Phind to do.

I shall provide an OpenAPI.yaml file for an appointment booking backend. You must use it to build a Python 3.11 based Flask application. You must integrate the app with Connexion 3.0.6. You must also use SQLAlchemy to integrate the database layer for all DB operations. You may use SQLite DB for the job for this demo. Also before you begin, please create the folder structure for the application.

Below is the content of the openapi.yaml file for your reference:

... paste the openapi.yaml content here ...

It instantly created a response and gave me instructions on how to create a project structure and the code required to build the project. The following steps were suggested by it:

Step 1. Set Up the Project Structure

It laid down a clear folder structure for the application.

appointment_booking/
│
├── app/
│   ├── __init__.py
│   ├── models.py
│   ├── schemas.py
│   ├── routes.py
│   └── database.py
│
├── tests/
│   └── test_appointments.py
│
├── openapi.yaml
└── requirements.txt

Step 2. Define the Database Model

It used SQLAlchemy and the openapi.xml definitions to come up with the following model code. It even suggested me to create the definition inside app/models.py

from sqlalchemy import Column, String, DateTime
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class Appointment(Base):
    __tablename__ = 'appointments'

    id = Column(String, primary_key=True)
    user_id = Column(String)
    service_id = Column(String)
    datetime = Column(DateTime)

Step 3. Set Up the Database

It then suggested me to create the Database connection in app/database.py like so:

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Step 4: Define the API Endpoints

Next it suggested me to generate the endpoints in the app/routes.py file.

from flask import jsonify
from app.database import SessionLocal
from app.models import Appointment

def get_appointments():
    db = SessionLocal()
    appointments = db.query(Appointment).all()
    return jsonify(appointments)

def create_appointment(appointment):
    db = SessionLocal()
    new_appointment = Appointment(**appointment)
    db.add(new_appointment)
    db.commit()
    db.refresh(new_appointment)
    return jsonify(new_appointment), 201

def get_appointment(id):
    db = SessionLocal()
    appointment = db.query(Appointment).filter(Appointment.id == id).first()
    if appointment is None:
        return jsonify({"error": "Appointment not found"}), 404
    return jsonify(appointment)

Step 5: Initialize the Flask Application

At this step, Phind suggested me to initialize the Flask application and integrate it with Connexion by writing the following code in app/__init__.py.

from flask import Flask
from connexion import FlaskApp

app = Flask(__name__)
connexion_app = FlaskApp(__name__, specification_dir='../')
connexion_app.add_api('openapi.yaml')

if __name__ == '__main__':
    app.run(debug=True)

Step 6: Install Required Packages

Now it asked me to add the required packages to app/requirements.txt

Flask==2.1.1
connexion==3.10.0
SQLAlchemy==1.4.32

Interestingly it even asked me to install these packages using the following Pip command:

pip install -r requirements.txt

Step 7: Run the Application

Finally it suggested me to run the application.

python -m app

I followed every single step Phind suggested to me and created a project in Visual Studio Code. I liked how it laid down in steps what a developer needs to do.

Next I tried to run the application without any modification to the code given by Phind to see if it works seamlessly without any changes.

Only additional step I took was to create a Virtual Environment to decouple and isolate Python installs and associated pip packages for this demo.

python3 -m venv venv

Next I activated the environment.

source venv/bin/activate

Running the App

After setting up the Virtual Environment, I ran the command pip -r install requirements.txt and came across the first error shown below.

It was a dependency error as Phind suggested use of a wrong version for connexion==3.10.0. The latest version is 3.0.6. Once I modified it, the dependencies were installed correctly.

Finally I ran the application as suggested in Step 7. But the app didn’t run successfully and threw yet another error.

ImportError: cannot import name 'url_quote' from 'werkzeug.urls'

I went back to Phind with the error and it suggested me to upgrade the Flask package to version 3.0.2. It took a couple of runs to get this working. I modified the app/requirements.txt file again and this is the most updated copy that worked:

Flask==3.0.1
flask-sqlacodegen==2.0.0
flask-swagger-ui==4.11.1
SQLAlchemy==2.0.25
SQLAlchemy-serializer==1.4.1
uvicorn==0.27.1
connexion[flask, swagger-ui, uvicorn]==3.0.6
starlette==0.36.3
Werkzeug==3.0.1

Once the dependencies were sorted, I ran the app again and this time I came across yet another error message:

/venv/bin/python: No module named app.__main__; 'app' is a package and cannot be directly executed

To avoid this error I moved the run function into a separate script file as suggested by Phind.

The new file was created in the root of the application and was named run.py

from app import create_app

import logging

logging.basicConfig(level=logging.DEBUG)
app = create_app()

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080)

As you can see, I have also added a function called create_app and defined it in the app/__init__.py. The modified code looks like this:

from connexion import FlaskApp
import app.routes

def create_app():
    
    connexion_app = FlaskApp(__name__, specification_dir='../')
    connexion_app.add_api('openapi.yaml', base_path='/api', arguments={'title': 'Appointment Booking API'})

    app = connexion_app.app
    
    return app

I kept trying to run the app from the terminal using the command python3 run.py and after a while, here’s what I see.

But when I try to access the API, it seems like, connexion would not bind with the functions property. I also added the operationId for each endpoint to the correct functions defined in the app/routes.py file. When we tried to access the API and the swagger-ui path, the application threw the following errors.

werkzeug.exceptions.NotFound: 404 Not Found: The requested URL was not found on the server. If you entered the URL manually please check your spelling and try again.

This only indicates that the app didn’t bind the openapi.yaml endpoints as expected.

NOTE: I also used the integrated Phind plugin console inside Visual Studio to ask it for suggestions and I was impressed that it could read my code and give me contextual help to my problem. Take a look at the interface below. I ask Phind to help me find the problem directly in the Visual Studio Code’s IDE and it came back with a detailed analysis of the problem and suggested me ways to fix it.

So, I gave it my best shot, but even with Phind’s help, I just couldn’t get the application up and running. It’s a bummer, I know. The thing is, I’ve got another app using the same stack that’s doing just fine in production, so I’m pretty confident that with a bit of elbow grease and some tweaking, I can make this one work too. But you know how it is – sometimes you just need to step away for a bit and come back with fresh eyes.

Anyway, my main goal here was to see how well Phind could lend a hand in building an app from the ground up. It was sort of an experiment, if you will. I figured I’d put it through its paces and see what it could do. But hey, no worries! I’m not throwing in the towel just yet. I’ll probably circle back to this project when I’ve got a bit more time on my hands.

Final Thoughts

My initial foray into building an appointment booking application with Phind wasn’t entirely successful. While the Flask backend code it generated served as a starting point, it will require significant troubleshooting to get a basic application running. This experience highlights that Phind might not be ideal for absolute beginners. However, for developers with more experience, Phind’s potential to streamline development is clear. The VS Code plugin that provides contextual help and answers to code-specific questions is a powerful tool that can significantly boost productivity. While Phind gets a 3 out of 5 for this project due to the challenges encountered, its potential for experienced developers remains promising.

To get a broader perspective on AI-powered development tools, I’ll be exploring Devin AI from Cognition Labs next. By comparing how Devin AI tackles the same appointment booking application challenge, I hope to provide valuable insights for developers seeking the most effective AI co-pilot for their projects. This head-to-head comparison will shed light on the strengths and weaknesses of each tool, helping developers make informed decisions about their coding workflow.

And for a deeper dive into Devin AI’s capabilities, check out my introductory article.