DEV Community: CommandDash

Code that’s Unseen - Library and Package Integration with Copilots

Samyak Jain — Mon, 14 Oct 2024 10:55:03 +0000

Software development heavily relies on third-party libraries and packages.

They evolve regularly, with new exposed methods, updating to support OS updates, and more. This poses a problem when using coding copilots that use LLMs trained on data with a cut-off date. Oct’23 for most latest models.

At CommandDash, we’re committed to solving this.

A Big Bump in the Road of Automating Software Development

Developers today can’t build apps without incorporating at least a dozen libraries. This integration is a fundamental aspect of software development.

While AI has excelled at generating code from thousands of interactions and data points, it struggles with integrating these packages due to unreliable code generation.

This isn’t acceptable and stands in the way of autonomous software development.

Efforts Being Made to Solve This

Many copilots are attempting to tackle this issue but often encounter fundamental problems:

Approach	Benefits	Limitations
Enabling Web Search	- Answers simple questions like the latest version of a package.	- Fails with complex queries. - High-level results aren’t useful for integration.
Indexing Documentation	- Helps in providing additional context to LLMs increasing quality by 20-30%.	- Many sites lack sitemaps or have paywalls. - Poorly written documentation. - Valuable info buried in support tickets.
GitHub Repository Indexing	- Provides deeper answers by referring to code and issues.	- Limited to open-source projects and frameworks.

In general, trust in these approaches is extremely low, and developers end up consulting documentation themselves.

Our Vision of Solving This: Infrastructure + Generated RAG

At CommandDash, our primary goal is to address the infrastructural issues to lay the groundwork for building world-class integrating copilots. We aim to create custom agents for all libraries using multiple data sources:

Scraping data from all package managers like NPM, PyPi, and Pub.dev.
Regularly re-indexing open-source repositories, including code, issues, PRs, wikis, and more.
Building AI-assisted website scrapers to handle even the most challenging websites.

We collect this data in parallel with user demands and interactions, enabling the community to contribute trusted sources like blogs and example repositories.

Generated RAG

Once we have all the data, RAG alone takes us only so far. From our observations:

When RAG Works	When RAG Fails
Single-scoped questions (e.g., how does {x} method work?)	Almost every other time.

Why?

It’s extremely difficult to find the right pieces of documentation from high-level user requirements. Our Langchain agent struggles to convert instructions like “write me code to count apples in an image” into correctly implemented code.
Even with the right documentation pieces, LLMs are poor at converting them into integration code. LLMs prefer examples over documentation.

This is why we need Generated RAG.

Generated RAG uses a small model continuously fine-tuned on a library’s data to generate examples for specific user use cases within ~1 second.

For instance, when a user asks, “write me code to count apples in an image”, the fine-tuned model on Langchain’s data should generate 2-3 examples of:

“Multimodal chat requests”,
“Counting prompt instructions”,
“Code implementation for the best multimodal models”

Then, a larger model (like Llama3) can use these examples as references instead of documentation pieces to generate a perfectly working piece of code.

We’re still on the journey to achieving this. Try CommandDash and share your thoughts with us.

How to really use AI Tools when building software.

Samyak Jain — Tue, 24 Sep 2024 06:09:18 +0000

AI is becoming an ingrained part of building software.

Besides the hype of magical features, the practical usage experience among developers stays basic. Talking to 100s of engineers from different geographies and experiences, here is what we've learned.

1. Clearly scope and define your task.

AI brings ambiguity and room for error in every step.

For example, commands like @workspace responsible for fetching the right files from your codebase to complete a certain task are still far from perfect.

For reliable results from your AI tool, provide it detailed task notes and required files yourself. Reduce it's role to only making the code edits.

2. Avoid big picture questions.

AI can only ingest a certain amount of code in its context window.

128K tokens for Gpt4o and 3.5 Sonnet.

While big picture decisions like architecture choices, feature specs require context from different places (multiple code repositories + docs + internal discussions) and a more ingrained understanding of your system.

Hence, it's best to only use AI as a suggestive help and make these decisions ourselves, which makes us worthy developers of AI age.

3. Ask to reason first.

As humans, we first think and then write code. LLMs work the best in the same manner. After defining your task, always ask:

"First think thoroughly and create a plan"
"List out all the edge cases and points to keep in mind"

4. Generate comments or tests for future context.

As we write more and more code using AI, we lost track of why certain decisions were made. And it's possible that the next revision with AI may overwrite them breaking our current system.

Ideally, we should write tests for every method as a documentation of every scenario a feature must handle. But if tests are not possible, ask LLMs to document your code with reasoning comments from your interactions with it.

5. Build custom agents for your needs.

Many times, general coding assistants aren't of help for our specific needs. You can levarage CommandDash to create your own coding assistants when

Integrating a new library or package
Onboarding on a new codebase and contributing to it.
Generating code matching a specific set of guidelines.

They have 1000+ agents pre-built. You can create your own as well.

Hope you find the article of help 🙏🏼

Build with any npm package with this AI assist 🦾

Samyak Jain — Fri, 16 Aug 2024 08:35:29 +0000

As Javascript developers, we use npm all the time. But diving into a new npm package can be a time sink.

But what if you had an AI assistant that knew the package inside out and can:

Help you decide if the package meets your needs.
How to integrate it in your codebase.
Debug compile and runtime issues.

Introducing AI Assist for NPM Packages

This tool creates custom AI agents trained on npm package repositories. Let's use cheerio as an example.

Here's how it works:

Create the AI Assist

Visit CommandDash which is a free tool to create agents for github libraries and npm, pypi and pub packages.

Tap on Create Agent button, and paste the npm package URL
Submit your URL and it will setup the agent for you.
Start Querying.

Now you can easily: 🤯

Decide if the package meets your needs.
Integrate it in your codebase.
Debug and fix issues.

Note: It can take a few minutes to prepare the agent.

Bonus: You can install the VSCode extension and use the agent in your IDE 🙌🏼

Give it a shot next time you're exploring a new package. It might just save you a few hours and a headache.

Happy coding! 🚀

This free AI agent will make you open-source king 👑

Samyak Jain — Tue, 06 Aug 2024 09:56:54 +0000

Software developers love open-source projects. But exploring a new project requires:

figuring how things work,
it' code structure, and
searching files and existing issues for your problem

which is challenging with a steep learning curve.

Introducing AI Assist for Github Projects

CommandDash is an AI tool that creates custom agents trained on code + issues of Github projects.

1. Let's pick a project that we want to work with.

For instance: Let's use the python library for Ollama.

2. Turn this into an AI Agent

Prefix the repository_url with this link that opens up the agent:

https://app.commanddash.io/agent?github= + repository_url

This creates an AI agent trained on the code + issues as above of any open-source repository. It may take 5-20 mins to finish indexing and then you can use it.

3. Ask your questions

You can ask the agent trained on the repo:

To summarize the repository code structure.
Search for specific files or issues.
Or, help you make contributions and build with it.

It's that simple! Bookmark this and use it next time you land on an open-source repository. 🙌🏼

Share it with your fellow developers and help them too!

Explore Open-Source Repos on Github faster with this AI URL ⚡️

Samyak Jain — Sat, 20 Jul 2024 09:30:19 +0000

If you are an open-source buff, chances are that you visit multiple github repositories and spend hours exploring them.

You may want to know
"What tech stack are their using?"
"How are their doing a particular X thing?"
"Where can I find the code that does Y?"
"How can I build Z using the repo?"

Well, there is an AI link that can help you get answers to your questions! without any setup.

Use this AI URL ⚡️

Just copy the link of the repository you would like to explore, and append it to https://app.commanddash.io/agent?github=<repo link>

This will open a web page where an AI agent will be trained on the repo.

It will take 2-20 mins to index, then you can start asking it any questions. It will also provide you links to the files and issues that were used to answer your question.

Try it out the next time you land on an open-source repository! 🙌🏼

Add this "AI Code Assist" badge to your Github Readme

Samyak Jain — Thu, 18 Jul 2024 11:35:03 +0000

If you are building an open-source project, there is a good chance that your readme is full of badges like this:

Badges help share the status of various aspects of your repo, it's popularity and link to helpful resources for visitors like documentation.

In the AI era, there is a badge that is missing. A badge that can help your users explore your repository 🌈 and build with it faster⚡️ without reading docs.

Introducing "AI Code Assist" Badge:

To add such badge to your repo, just add the below to your readme.

<a href="https://app.commanddash.io/agent?github=<your github repo>"><img src="https://img.shields.io/badge/AI-Code%20Gen-EB9FDA"></a>

Replace <your github repo> with your Github Repository URL, for example: https://github.com/apify/crawlee-python

This will create an AI code assist trained on your code + issues in your repository.

Developers can click the badge, to access the code assist directly in a web app.

They can ask any questions are quoted with links to code and issues from your repository along with the answer.

Sounds great right? 🤩 Add it to your repo and help developers build faster!

Using RAG to Build Your IDE Agents

Yogesh Choudhary — Tue, 18 Jun 2024 21:59:22 +0000

In the post-GPT revolution era, many of us developers have started using LLM-enabled tools in our development workflows. Nowadays, you can complete new and complex development tasks in a short span with the help of theses LLM tools when used correctly.

Until you start using them for anything related to new APIs or SDKs or their latest version, this is the place where they fall short.

Fixing the Shortcomings with RAG

At CommandDash (formerly Welltested), our team has been working in code generation. Like other organizations in this field, we recognized the challenges and have actively developed solutions.

Therefore, with the Dash Agent Framework, we initiated building a robust RAG system to tackle these issues from inception stage itself.

What is RAG?

Retrieval-Augmented Generation (RAG) is a powerful technique that combines the capabilities of LLMs with relevant references to enrich the responses. These relevant references are typically derived from external knowledge sources like document databases and more.

RAG significantly enhances the capabilities of LLMs, especially when working with new packages and frameworks. By accessing up-to-date information from documentation, code examples, and other sources, RAG-based LLMs can:

Provide accurate and contextual responses: Instead of relying solely on pre-trained data, LLMs can access the latest documentation and code examples to provide accurate and relevant information.
Adapt to evolving technologies: As APIs and SDKs evolve, RAG can keep pace by constantly updating its knowledge base from official sources.

In this blog, we will build a powerful IDE agent for PandasAI using Dash Agent. Then later on, we'll understand how using RAG can significantly improve LLM responses.

Building PandasAI Agent

PandasAI is a Python platform that makes it easy to ask questions about your data in a natural language. It integrates generative artificial intelligence capabilities into pandas to allow you to extract insights effortlessly.

Now that you're familiar with PandasAI. Let's start our journey to build our own PandasAI agent. The job of this agent will be to assist developers in building and integrating PandasAI code efficiently.

Prerequisite Steps

1. Install Dart
Dash Agent is built upon dart language. If you haven't already, follow the official Flutter installation instructions here.

2. Install dash_cli
Now, install the dash_cli command line tool that enables you to create and publish your agents at the CommandDash marketplace. Open your terminal and run the following command:

dart pub global activate dash_cli

Create PandasAI Project

Next, you will create the pandas_ai project. This is the place where you will define your agent configurations. Run the following command in the terminal:

dash_cli create pandas_ai

This will create a dash agent project that contains the template code agent building. Then, open the project in your preferred IDE where the flutter extension is installed.

Adding Agent Data Sources

The core of a RAG-based agent lies in its knowledge base, known as data sources. These sources provide the agent with context and information to understand and respond to user requests.

For our PandasAI agent, we will gather data from the following sources:

Official PandasAI Documentation: https://docs.pandas-ai.com, https://pandasai-docs.readthedocs.io/en/latest
Official Examples and Issues shared by PandasAI team: https://github.com/sinaptik-ai/pandas-ai
Other Open Source Examples: CSV Chatbot, GroqMultiCSVChatPandasAI , MutipleCSVChatllama3Pandasai, PandasAI-Tutorials

Navigate to the lib/data_sources file in your project and replace the existing code with:

import 'package:dash_agent/data/datasource.dart';
import 'package:dash_agent/data/filters/filter.dart';
import 'package:dash_agent/data/objects/file_data_object.dart';
import 'package:dash_agent/data/objects/project_data_object.dart';
import 'package:dash_agent/data/objects/web_data_object.dart';

// Indexes all the documentation related data
class DocsDataSource extends DataSource {
  @override
  List<FileDataObject> get fileObjects => [];

  @override
  List<ProjectDataObject> get projectObjects => [];

  @override
  List<WebDataObject> get webObjects => [
        WebDataObject.fromSiteMap('https://docs.pandas-ai.com/sitemap.xml'),
        WebDataObject.fromSiteMap(
            'https://www.xml-sitemaps.com/download/pandasai-docs.readthedocs.io-a2835e7d4/sitemap.xml?view=1'),
      ];
}

// Indexes all the example code and issues related data
class ExampleDataSource extends DataSource {
  final accessToken = 'your_personal_github_access_token';
  @override
  List<FileDataObject> get fileObjects => [];

  @override
  List<ProjectDataObject> get projectObjects => [];

  @override
  List<WebDataObject> get webObjects => [
        WebDataObject.fromGithub(
            'https://github.com/sinaptik-ai/pandas-ai', accessToken,
            codeFilter: CodeFilter(pathRegex: r'^examples\/.*')),
        WebDataObject.fromGithub(
            'https://github.com/ismailtachafine/PandasAI-CSV-Analysis',
            accessToken,
            codeFilter: CodeFilter(pathRegex: r'.*\.py$')),
        WebDataObject.fromGithub(
            'https://github.com/kBrutal/CSV_ChatBot', accessToken,
            codeFilter: CodeFilter(pathRegex: r'.*\.py$')),
        WebDataObject.fromGithub(
            'https://github.com/InsightEdge01/GroqMultiCSVChatPandasAI',
            accessToken,
            codeFilter: CodeFilter(pathRegex: r'.*\.py$')),
        WebDataObject.fromGithub(
            'https://github.com/InsightEdge01/MutipleCSVChatllama3Pandasai',
            accessToken,
            codeFilter: CodeFilter(pathRegex: r'.*\.py$')),
        WebDataObject.fromGithub(
            'https://github.com/TirendazAcademy/PandasAI-Tutorials',
            accessToken,
            codeFilter: CodeFilter(pathRegex: r'.*\.py$')),
      ];
}

The above code shared the references of sources that need to be indexed both the documentation and examples. Apart from the sources link, you have also provided accessToken and codeFilter:

accessToken: During processing, the CommandDash server indexes data for WebDataObject.fromGithub via Github's official API. To fetch the data from the GitHub API efficiently, the personal github token is required and can be easily generated by visiting the tokens page.
CodeFilter: This filter enables the framework to selectively index the code files based on the regex shared. This is optional.

Note: Your Personal Access Token is very sensitive data. Please make sure not it share it with anyone or push it to any public source.

You can learn more about WebDataObject and associated properties in detail at CommandDash documentation.

Adding Agent System Prompt and Metadata

Next, you'll add system prompt and agent metadata to the AgentConfiguration class. Navigate to lib/agent.dart file and replace the existing code with:

import 'package:dash_agent/configuration/metadata.dart';
import 'package:dash_agent/data/datasource.dart';
import 'package:dash_agent/configuration/command.dart';
import 'package:dash_agent/configuration/dash_agent.dart';
import 'data_sources.dart';

class PandasAI extends AgentConfiguration {
  final docsDataSource = DocsDataSource();
  final exampleDataSource = ExampleDataSource();

  // Add the metadata information about PandasAI agent
  @override
  Metadata get metadata => Metadata(
      name: 'Pandas AI',
      avatarProfile: 'assets/logo.jpeg',
      tags: ['LLM Framework', 'Data Analysis']);

  // Add the systemPrompt for dash agent's commandless mode (also know as chat mode). 
  // System prompt is a key component for conversational-style agents. As it provides 
  // the initial context and guidance regarding the agent's purpose and functionality to the LLM.
  @override
  String get registerSystemPrompt =>
      '''You are a Pandas AI assistant inside user's IDE. PandasAI is a Python library that makes it easy to ask questions to your data in natural language.

      You will be provided with latest docs and examples relevant to user questions and you have to help them achieve their desired results. Output code and quote links and say I don't know when the docs don't cover the user's query.''';

  // Add the data sources that needs to indexed for RAG purposes.
  @override
  List<DataSource> get registerDataSources =>
      [docsDataSource, exampleDataSource];

  @override
  List<Command> get registerSupportedCommands => [];
}

The above code basically glues everything all together for the PandasAI agent - data source, metadata, system prompt, commands, etc. that are needed to build the dash agent.

For more details related to the AgentConfiguration please read the dash_agent framework.

Finally, head to bin/main.dart file and replace the existing code with:

import 'package:dash_agent/dash_agent.dart';
import 'package:pandas_ai/agent.dart';

/// Entry point used by the [dash-cli] to extract your agent
/// configuration during publishing.
Future<void> main() async {
  await processAgent(PandasAI());
}

That's it. Your agent is now configured and ready to be used. Next, you'll publish it so that it can be tested and shared with other devs as well.

Publishing the PandasAI Agent

You need to be logged in to dash_cli using GitHub auth to publish your agent. Run the following command in the terminal to login:

dash_cli login

Finally, run the following command in the terminal from the root folder of your pandas_ai project to publish the agent:

dash_cli publish

This will validate the configuration and if all looks good. It will schedule your agent publication. Once your agent is ready to be used. You will get an email confirming the successful publication and PandasAI will be visible in the CommandDash Marketplace:

What's Next

Congratulations! 🎉 Now you know how to create powerful agents using the Dash Agent framework. These agents leverage the power of RAG and LLMs. We're excited to see the innovative agents you'll build with Dash Agent.

Also, don't forget to try out the PandasAI agent, which is currently live on the CommandDash extension for VS Code. Check it out here.

Next up, we will see in our upcoming blog, how well PandasAI perform. Stay tuned!

5 VSCODE AI Extensions for devs in 2024

Samyak Jain — Fri, 14 Jun 2024 07:44:29 +0000

As somebody who has been building AI developer tooling for about a couple years now, I like to keep an eye on what are the most productive extensions that developers can utilize.

Today, I'm sharing a list of top 4 extensions + CommandDash based on some recent surveys by StackOverflow and my own findings.

1. Github Copilot (Paid)

Copilot is the go to programming assistant for most professional developers.

It comes with features like auto complete and chat and can help you with most of your coding tasks.

2. Codeium (Free)

With 1.1M downloads, Codeium stands as the top free AI Coding extensions. It offers the same feature set as Copilot and is stable and trusted.

They have recently raised 65M$ as their Series B so we can expect the extension to be improved further in the upcoming months.

It is a good idea to either have one of Copilot or Codium enabled in their IDE. Though personally, I don't use any of them and rely on CommandDash which solves the needs for me.

3. Codiumate (Free)

If you are a developer that believes in writing code tests - this is the extension for you.

They have focused on building specialized testing and PR review copilot that supports most programming languages.

4. ChatGPT - Genie AI (Bring your own Key)

If you are a ChatGPT user, this extension brings it to your VSCode. You can put in your OpenAI key and get stared!

Though very popular, it seems like that the team is not actively maintaining the extension, so please use with caution.

5. CommandDash (Bring your own Key)

CommandDash is World's first marketplace of programming agents in VSCode.

The agents are expert at specific tooling and are trained on it's docs, examples and Github issues. For example, if you want to build with Langchain, just install the agent for it from their marketplace.

You can then ask any questions and get contextualized integration code without having to read it's documentation:

It is completely open sourced and anybody can publish on the marketplace. You can read more about them here.

There are a lot many other extensions that are growing fast and I'd soon cover them in another post.

Share know what extensions are you using in the comments!

Understanding Dash Agents: A LangChain Case Study

Yogesh Choudhary — Wed, 12 Jun 2024 18:23:51 +0000

In software development, integrating APIs and SDKs is crucial. Yet, the process can be tedious and time-consuming. Documentation, syntax complexities, and debugging can quickly become time-consuming roadblocks. Thankfully, this is where Dash Agents comes in to ease these headaches.

This blog post explores the capabilities of Dash Agents. It shows how they simplify the integration of APIs and SDKs for tools and frameworks like LangChain.

What is LangChain?

LangChain is a framework that allows users to integrate LLMs into their projects. It provides a comprehensive toolkit for:

Model Handling: It supports various LLMs and allows for easy integration of custom models, offering prompt templates and engineering tools.
Data Processing and Pipelines: LangChain provides tools for data preprocessing and augmentation, along with the ability to create custom pipelines with a modular design.
Deployment and Monitoring: It supports cloud deployment and scaling, offers evaluation metrics and real-time monitoring, and ensures security and compliance measures are in place.

You can learn more about the LangChain framework on their Official site.

Introducing LangChain Agent

Imagine having an intelligent assistant in your IDE. It's always there to help you integrate any LangChain-based code into your project. That's precisely what the LangChain Dash Agent offers.

Why You'll Love LangChain Agent:

Extensive API Knowledge: It is shared with vast knowledge of LangChain framework documentation and sample codes, allowing it to provide nearly accurate code and insights.
Contextual Awareness: It is designed to respond to queries with the understanding of your codebase and project context. Thus, capable of providing better assistance and solutions.
Saving Time During Coding: It generates the required code for you and if required debugs the code for you, saving you a lot of time. Thus, forget the days of tedious manual API docs searching and then coding only to realise that you need to fix a bug by searching multiple sources.

Install LangChain Agent

Let's start by setting up your agent. If you've already LangChain installed please continue to the next section.

1. Install CommandDash Extension

Head over to the VS Code Marketplace and search for "CommandDash." Install the extension.

2. Sign in to CommandDash

Open the extension once installed. You'll need to sign in and provide your Gemini key.

3. Install LangChain Agent

Then, go to the CommandDash Marketplace within your Extension.

Search for "LangChain" and install the agent.

Next, it's time to put the installed LangChain agent to use.

Getting Started with LangChain Agent

Finally, it is time to put the agent to work with a compelling use case: building a creative text generator in Python.

This program takes the starting phrases of the poem as input. Then, it uses an LLM to extract the user's writing style and generate the remaining part of the poem.

Start by activating the LangChain agent. In your CommandDash extension, type @ in the bottom text field and select "LangChain" from the dropdown:

This activates the agent within your current workspace.

For demo purposes, we will attempt to use OpenAI's latest model - "GPT-4o". Type the following query into the CommandDash text field:

"Generate the Python code to create an application to generate poem with the user-supplied initial phrases using OpenAI gpt-4o model"

The agent will analyze your request and will respond something like:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage, SystemMessage

os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"

def generate_poem(initial_phrases, model="gpt-4o"):
    """Generates a poem using OpenAI's GPT-4o model.

    Args:
        initial_phrases (list): A list of initial phrases to start the poem.
        model (str, optional): The OpenAI model to use. Defaults to "gpt-4o".

    Returns:
        str: The generated poem.
    """

    llm = ChatOpenAI(model=model)

    prompt_template = ChatPromptTemplate.from_messages(
        [
            SystemMessage(content="You are a helpful and creative poet. Generate a poem using the following initial phrases as inspiration: "),
            HumanMessage(content=" ".join(initial_phrases))
        ]
    )

    messages = prompt_template.format_messages()
    response = llm.invoke(messages)

    return response.content

if __name__ == "__main__":
    initial_phrases = input("Enter your initial phrases separated by commas: ").split(",")
    poem = generate_poem(initial_phrases)
    print("Generated Poem:\n\n", poem)

Explanation:
Some explanation about the code
...

In our case, we haven't asked for any API integration request but rather an app itself. Thus, the agent supplied us with the whole end-to-end Python code.

Copy the code to a blank Python file and read the generated code. Right now, you can also update the code as needed. For instance, the current generated code is missing the import os statement. So, I will manually add the missing import.

Tip: At times, if you ever feel like the solution isn't straightforward, or you want to explore the problem more deeply or find a quick fix. Feel free to continue conversing with the agent.

Finally, add your OpenAI API key and run the app by executing the updated code:

Closing Thoughts

LangChain agent is not all that CommandDash has to offer. We have more agents for various APIs and SDKs, such as Firebase Genkit, Pandas AI, Vercel AI, and more.

Additionally, we also allow developers like you to create public agents for your teams and other developers. If interested, do visit the Dash Agents Docs.

That concludes this blog post. Now it's time to try it out yourself and materialize your LangChain use case to code instantly with CommandDash. We always love to hear what you build!