DEV Community: Sachin Uplaonkar

AI Agents: Transforming Ideas into Action, Collaboratively

Sachin Uplaonkar — Wed, 27 Nov 2024 05:16:25 +0000

What is an AI Agent?

In simple terms, an AI agent is a program designed to meet user expectations with minimal to no input, functioning autonomously to achieve its objectives.

Think of it like a beehive hierarchy: worker bees, the queen bee, and drone bees each have distinct roles, yet they collaborate seamlessly to achieve a common goal. Similarly, AI agents specialize in tasks while working together to accomplish complex objectives.

With rapid advancements in artificial intelligence, the concept of Agentic AI is making waves. Industry leaders like Andrew Ng have highlighted how AI agents represent the next significant leap in AI evolution. In his recent talk, Andrew provided valuable insights into the current state of AI agents and how they can be harnessed for diverse applications.

Why AI Agents?

Developers know all too well the arduous process of building, testing, and deploying applications — a journey that can take weeks or even months. Enter AI orchestration frameworks like LangChain (LangGraph), CrewAI, OpenAI (Swarm), and Haystack, which have drastically reduced this timeline. Now, tasks that once took months can be completed in days — or even hours in some cases.

AI Agentic Design Patterns

As explained by Andrew Ng, there are four primary design patterns for creating AI agents:

1. Reflection

This pattern mirrors the human interaction loop found in apps like ChatGPT or Perplexity. It’s a request-response cycle where agents interact, research, and refine their output until they meet user expectations. Unlike human-driven iterations, agents autonomously handle the back-and-forth process to deliver results.

2. Planning

In this approach, a large task is broken down into smaller, manageable subtasks. Each agent is assigned a specific task, and the results are aggregated into a final cohesive output.

3. Tools

Agents utilize external resources — such as Python scripts, APIs, or web scrapers — to accomplish their tasks. This pattern leverages the versatility of tools to enhance agent capabilities.

4. MultiAgent

Imagine a professional team, with each member bringing specialized expertise — developers, product planners, QA engineers, and more. MultiAgent systems operate similarly, using a collaborative, supervised, or hierarchical approach where agents with unique strengths (different models) work together to achieve a unified goal.

For a deeper dive into these patterns, you can explore Andrew Ng’s original explanation here.

CrewAI: Agent Orchestration Framework

CrewAI is a notable orchestration platform that simplifies the development of multi-agent solutions. While numerous tutorials are available, the best starting point is their official documentation, which offers detailed guidance on framework concepts, technical terminology, and structuring agent-based projects.

Flight Finder and Trip Planner with CrewAI

To demonstrate the power of CrewAI, I built a project that streamlines flight search and trip planning. The tool not only finds flights but also crafts a destination itinerary — all with minimal effort. No more tedious searches, web scraping, or wrangling with messy HTML tags!

Code Structure

The project adheres to CrewAI’s quickstart guide:

Config folder: Contains agents.yaml and tasks.yaml.
- Agents: Defined as experts with roles, goals, and backstories.
- Tasks: Specify objectives, expected outputs, the agent responsible, and contextual dependencies between tasks.
Custom Tool: The google_flights.py script interacts with the Google Flights API (via SerpAPI) to retrieve flight details.
Serper API Integration: CrewAI’s built-in support simplifies web scraping tasks.
LLM Model: OpenAI’s GPT-4o powers the solution.

Output

The final itinerary is saved as a trip_itinerary.md file, providing a neatly formatted travel plan if run via crewai run command.

Users can run it as a streamlit app by following the instructions mentioned in the README of the repo.

The project code is available on GitHub. CrewAI GitHub repo has a list of curated open-source projects, check them out if interested in learning more and how the community is building.

Impact of Agents

As previously stated, with frameworks like CrewAI, iteration of an idea to implementation can be done in a few hours to days and then deployed to production. The future of development will be more focused on ideas, the clear concise way to write a prompt, and less tinkering at the code level.

Unlocking Knowledge!

Sachin Uplaonkar — Fri, 22 Nov 2024 04:49:36 +0000

AI is revolutionizing the way we learn…

Welcome to the Future of AI with ExplainIt

In a world where information is abundant but often complex, it isn’t easy to meet everyone’s level of understanding. With the advent of AI, learning has been revolutionized, and a concept that was once explained well by a few is now at the tips of a few prompts! ExplainIt project is an attempt to simplify the learnings and clarify the topics of interest. Powered by CrewAI, this application is designed to break down intricate issues into simple, digestible explanations. Let’s explore what makes ExplainIt and CrewAI so exciting, and how they shape the future of artificial intelligence.

What is CrewAI?

CrewAI is a cutting-edge framework that orchestrates autonomous AI agents to work collaboratively. Imagine a team of AI agents, each with its role and expertise, coming together to tackle complex tasks more efficiently than any single agent could alone. This collaborative intelligence allows for seamless interactions among agents, making CrewAI a game-changer in the realm of automation and AI.

The Power of Agents

At the heart of CrewAI are agents — intelligent entities designed to perform specific tasks. Each agent can assume roles, share goals, and operate cohesively within a crew. For instance, you might have a researcher agent who investigates new trends while a writer agent crafts compelling content based on those findings. This role-based design not only enhances efficiency but also allows for dynamic task management, where agents can autonomously delegate tasks among themselves.

Why ExplainIt

The ExplainIt project is an attempt to exemplify the potential of CrewAI by focusing on simplifying knowledge dissemination. By leveraging advanced language models like Llama3.2, ExplainIt takes complex subjects and distills them into clear explanations. This capability is particularly valuable in educational contexts or for anyone eager to learn without wading through technical jargon. The app is available on GitHub and one can use either the CLI version or via Streamlit app, this is a basic app that just modifies the configs of the template provided by CrewAI. But imagine the way it can be extended!

The Future of AI Agents

As we look ahead, the future of AI agents appears bright and full of potential. The demand for intelligent automation is growing rapidly across industries, and platforms like CrewAI are at the forefront of this transformation.

Key Trends to Watch

Increased Collaboration: We can see more collaboration among different agents and platforms across various systems, creating a more interconnected AI mesh!
Enhanced Autonomy: As technology evolves, agents will become even more autonomous, given a task, they figure out how to achieve it without much human interference.
Broader Applications: Currently, we are seeing the trend of use of AI agents in the customer service fields, we can expect similar trends to follow in other sectors.
Community-Driven Innovation: With an open-source foundation, companies like Meta, and CrewAI are encouraging everyone to get a taste of AI and the things that can be achieved with it. Thereby unlocking many use cases.

Conclusion

The ExplainIt project powered by CrewAI is not just about simplifying explanations; it represents a significant leap toward harnessing the power of collaborative AI agents. As we move forward, embracing these technologies will be crucial in navigating an increasingly complex world. Whether you’re an educator, a student, or simply a curious learner, tools like ExplainIt are paving the way for a future where knowledge is more accessible than ever before. Join us on this exciting journey into the realm of AI!

ReviewIt-AI

Sachin Uplaonkar — Mon, 04 Mar 2024 23:43:37 +0000

A companion to help you write better code!

We all have been in this situation of going through the code and providing our inputs in improving it before it gets to be part of the larger system, but often things get lost in translation to bring forth the idea behind it and the way the reviewer sees it.

With the ever-increasing penetration of GenAI into our lives, it makes more sense to use it to our advantage to help out both the author and the reviewer.

Welcome to ReviewIt-AI!

ReviewIt-AI takes in your code, provides a summary of what it does, and suggests improvements if needed. It is based on LangChain, OpenAI, and Streamlit

A sample of it:

ReviewIt-AI

ReviewIt-AI: Sample Code Review

Then a question arises, is this helpful on its own? Sure, if you just need a quick check on your code or need a quick summary of what the code does. But in the longer run, it will be more useful if it is part of your review process🌟 enter…

ReviewIt-AI GitHub Actions

With a working example in place, we can focus on getting it part of a PR review process using GitHub’s Action. Let me share the overview of it:

GitHub Actions are nothing but workflows that get triggered based on the event one defines in the yml file(s) of the workflows. In our case, we have the directories actions and workflows defined within the .github folder.

Actions are where we write/store scripts that will be called by the Workflows during execution, here we have ai.py and reviewit.py, as the file names suggest, each contains the code that does respective actions, and with reviewit.py being our main file, we will call ai.py in it and also, define what our review comments look like.

Workflows consists of yml files that call actions to be performed based on user-defined plans. In our case, it is to execute actions on every PR, summarize what the PR is trying to do, and provide an opinion on things to be improved with suggested code changes.

In the code base, you can find two PRs, one corresponds to a code that can be improved, and the other one better code

Overview of Workflow Code

name: ReviewIt-AI

on:
  pull_request:
    branches:
      - main
    types: [opened, synchronize]

The above code showcases the initial code, we name our workflow as ReviewIt-AI and we would like to execute this GitHub action for every PR.

jobs:
  review:
    runs-on: ubuntu-latest
    env:
      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
      GIT_TOKEN: ${{ secrets.GIT_TOKEN}}
      PR_NUMBER: ${{ github.event.number }}
      REPO: ${{ github.repository }}

Next, we define the jobs that get triggered, one can create multiple jobs but here we just need one, we define which OS runs the code on and supply the required environment keys like OpenAI, GitHub Token (PAT) and we collect the repo and pr_number

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.11.5"
          cache: "pip"

Next, we checkout the repo using Python GitHub Actions and provide the version we need.

      - name: Install dependencies
        run: |
          pip install -r requirements.txt --quiet

Install required dependencies

      - name: Run ReviewIt-AI
        id: review
        run: |
          echo $REPO
          echo $PR_NUMBER
          echo "python .github/actions/reviewit.py -r $REPO -p $PR_NUMBER"
          python .github/actions/reviewit.py -r $REPO -p $PR_NUMBER | tee output.txt

This is the section where we call the actions to be triggered, here, we call it to execute the reviewit.py that gets the PR contents and sends it to OpenAI to get a summary, improvements, and reviews and store the output in a file called output.txt, also, the output can be viewed in the console of this particular step.

The final step in our process is to add it as a comment to our PR. In the previous step, we used output.txt file to store the results, so here we read it and pass it as a body of the PR.

That’s all we need!

Things to remember

Make sure to generate the PAT token
Provide required permissions to it, like either to a specific repo or all repos and other fine-grained permissions
Go to the repository where you want to enable the GitHub Actions
In the repo Settings >> Actions >> provide necessary permissions for the workflows (check the ‘Workflow permissions’ section)
Add your PAT token as well as the OPENAI_API_KEY in the repo's secrets

Note: In the current repo, the secrets are dummies, so, the GitHub Actions on any new PRs will fail

Go ahead and clone the repo and have it part of your repo to get your PRs auto-reviewed!

Sample Comments

Code that can be improved:

Better Code:

Code Links

Multi-Modal Agentic RAG using LangChain

Sachin Uplaonkar — Wed, 28 Feb 2024 15:07:49 +0000

Explore the world of agents…

Most of you might have explored the world of RAG (Retrieval Augmented Generation) to chat with your documents and explored the world of generating images as well. With the capability of function calling now baked into most of the GenAI model providers, the applications are limitless.

Agents

Agents are kind of mini tasks that help you to achieve your specific goals. When multiple agents are combined, they form an indispensable force. Like one program to help you chat with LLMs, make a call to an external API, translate, image generation, etc. Today let’s explore the agents that help us:

Chat with any PDF
Get recent papers from paperswithcode
Use Dall-E-3 to generate artistic abstract images

Code

The code is available on GitHub with well-structured getting started steps.

I will be giving a brief overview of it here:

The technology stack that we will be using is: LangChain, OpenAI, paperswithcode API, ChromaDB, and Dall-E-3.

Upload your PDF document in the docs folder and explore the default agents. If interested, go ahead with creating your agents by adding them to the services folder and creating a corresponding tool in the tools folder.

The option to execute the code in Gradio or Streamlit is provided with the default code running as Streamlit. I found it difficult to showcase the image/text in Gradio, hence the switch to Streamlit.

Restrictions

The code is restricted to answer only from the document, if you ask outside of it, the app won’t make a query to the outside world to fetch the response (which in most cases we want if dealing with sensitive documents).

Results

Following are some of the responses from the app, note: the image prompt was taken from Google

Feel free to play around and use it for your own with extended agents!

Add-On

It is always good to know the full trace of your query, I would suggest you try LangSmith from LangChain. It provides a whole lot of information on how your query is passed over different stages, and also the cost associated with each of them.

Cut a Release Branch!

Sachin Uplaonkar — Fri, 12 Jul 2019 04:06:16 +0000

Hello, this is my first post here!

Recently, I was given the task to handle the release process and the requirement was to create/cut a release branch off of the default branch for 3-5 repositories and deploy them on different environment (like dev) so that the QA team could take those branches, deploy and continue with their tests without affecting the development workflow.

So, here is the Python script that I created for doing this. Let me know of any improvements and/or suggestions! Cheers...

GitHub Link: https://github.com/sachs7/cut-release