DEV Community: Matan Abramovich

11 Open-Source Projects That Will Rocket Your Resume 🚀 (Jumpstart Your Career in 2024! 🌟✨)

Matan Abramovich — Mon, 18 Dec 2023 21:10:34 +0000

TL;DR

How can you give your coding career a mega boost?

Contributing to Open Source projects can get you noticed by the right people.

I've selected a range of projects that will level up your skills and real-world experience, making your resume stand out to potential employers. Perfect for developers at any stage, contributing to these projects will expand your tech toolkit and propel your professional journey forward.

DON'T FORGET TO STAR & SUPPORT THEM 🌟

Fuel the AI revulotion 🔥🤖

1. Pezzo

Pezzo is an Open Source LLMOps platform, built for full stack developers with first class TypeScript support.

Pezzo is the fastest growing Open Source LLMOps platform, used by dozens of product teams to build, monitor, and ship AI features with confidence.

⭐️ Pezzo on Github

pezzolabs / pezzo

🕹️ Open-source, developer-first LLMOps platform designed to streamline prompt design, version management, instant delivery, collaboration, troubleshooting, observability and more.

Pezzo is a fully cloud-native and open-source LLMOps platform. Seamlessly observe and monitor your AI operations, troubleshoot issues, save up to 90% on costs and latency, collaborate and manage your prompts in one place, and instantly deliver AI changes

✨ Features

Documentation

Click here to navigate to the Official Pezzo Documentation

In the documentation, you can find information on how to use Pezzo, its architecture, including tutorials and recipes for varius use cases and LLM providers.

Supported Clients

Feature	Node.js • Docs	Python • Docs	LangChain
Prompt Management	✅	✅	✅
Observability	✅	✅	✅
Caching	✅	✅	✅

Looking for a client that's not listed here? Open an issue and let us know!

Getting Started - Docker Compose

If you simplay want to run the full Pezzo stack locally, check out Running With Docker Compose in the documentation.

If you want to run Pezzo in development mode, continue reading.

…

View on GitHub

2. CopilotKit

CopilotKit is an open-source platform designed to accelerate the development of copilot applications.

This is an infrastructure that makes it way easier to integrate key AI features into React apps.

⭐️ CopilotKit on Github

CopilotKit / CopilotKit

react UI + infrastructure for AI Copilots, in-app AI agents, AI chatbots, and AI-powered Textareas 🪁

Here for Hacktoberfest? 🎉 Get started here 🚀 🎊.

CopilotKit is the open-source framework for integrating powerful AI Copilots into any application. Easily implement custom AI Chatbots, AI Agents, AI Textareas, and more

👉 Check out the docs at https://docs.copilotkit.ai

Table of Contents

Getting Started

Quickstart & Tutorials

There are several easy ways to get started with CopilotKit:

Quickstart: Chatbot: In just two minutes, add an AI Chatbot to your app with the ability to read application state and take actions.
Tutorial: Todo List Copilot: For a deeper dive into CopilotKit, take a simple todo list app and supercharge it with an AI chat popup.
Tutorial: Textarea Autocomplete: For a deeper dive into CopilotKit, we'll take a simple email client app and add an AI-powered textarea with autocompletions and AI insertions/edits.

…

View on GitHub

3. GPT-researcher

GPT Researcher is an autonomous agent designed for comprehensive online research on a variety of tasks.

This is a great project that I mainly use as a search engine for AI agents, I love using it and even have a tutorial showing how you can use it too!

🤖 Build an AI assistant with real-time web access in 100 lines of code using Python and GPT-4 🌍

Matan Abramovich ・ Nov 20 '23

#tutorial #python #productivity #beginners

⭐️ gpt-researcher on Github

assafelovic / gpt-researcher

LLM based autonomous agent that does online comprehensive research on any given topic

English | 中文 | 日本語 | 한국어

GPT Researcher is an autonomous agent designed for comprehensive online research on a variety of tasks.

The agent can produce detailed, factual and unbiased research reports, with customization options for focusing on relevant resources and outlines. Inspired by the recent Plan-and-Solve and RAG papers, GPT Researcher addresses issues of misinformation, speed, determinism and reliability, offering a more stable performance and increased speed through parallelized agent work, as opposed to synchronous operations.

Our mission is to empower individuals and organizations with accurate, unbiased, and factual information by leveraging the power of AI.

Why GPT Researcher?

To form objective conclusions for manual research tasks can take time, sometimes weeks to find the right resources and information.
Current LLMs are trained on past and outdated information, with heavy risks of hallucinations, making them almost irrelevant for research tasks.
Current LLMs are limited to short token outputs…

View on GitHub

4. Swirl

This search engine is unique because on top of getting data off the web you can connect it directly to your database (SQL, NoSQL, Google BigQuery) or enterprise sources(Microsoft 365, Jira, Miro, etc.). It will search multiple content sources and return AI ranked results.

⭐️ Swirl on Github

swirlai / swirl-search

SWIRL AI Connect: AI infrastructure software that powers your Search & Retrieval Augmented Generation (RAG) applications. Simplify and enhance your AI pipelines with seamless integration of large language models (LLMs) and data sources.

SWIRL AI Connect

Bring AI to the Data, not the Data to the AI

SWIRL AI Connect is advanced AI infrastructure software. It supports enhanced Retrieval Augmented Generation (RAG) capabilities, powerful analytics, and SWIRL Co-Pilot. SWIRL harnesses AI for business, enabling organizations to make better decisions and take more effective and timely actions.

Start Searching · Slack · Key Features · Contribute · Documentation · Connectors

Get your AI up and running in minutes, not months. SWIRL AI Connect is an open-source AI Connect platform that streamlines the integration of advanced AI technologies into business operations. It supports powerful features like Retrieval-Augmented Generation (RAG), Analytics, and Co-Pilot, enabling enhanced decision-making with AI and boosting enterprise AI transformation.

SWIRL operated without needing to move data into a vector database or undergo ETL processes. This approach not only enhances security but also speeds up the deployment. As a private cloud AI provider…

View on GitHub

5. pgvector

Generative AI models can use a special type of data structure called "embeddings" to make any use out of this we need to use a vector database.
With pgvector extension, you can leverage PostgreSQL as a vector database to store and query LLM generated embeddings.

⭐️ pgvector on Github

pgvector / pgvector

Open-source vector similarity search for Postgres

pgvector

Open-source vector similarity search for Postgres

Store your vectors with the rest of your data. Supports:

exact and approximate nearest neighbor search
single-precision, half-precision, binary, and sparse vectors
L2 distance, inner product, cosine distance, L1 distance, Hamming distance, and Jaccard distance
any language with a Postgres client

Plus ACID compliance, point-in-time recovery, JOINs, and all of the other great features of Postgres

Installation

Linux and Mac

Compile and install the extension (supports Postgres 12+)

cd /tmp
git clone --branch v0.7.4 https://github.com/pgvector/pgvector.git
cd pgvector
make
make install # may need sudo

See the installation notes if you run into issues

You can also install it with Docker, Homebrew, PGXN, APT, Yum, pkg, or conda-forge, and it comes preinstalled with Postgres.app and many hosted providers. There are also instructions for GitHub Actions.

Windows

Ensure C++ support in Visual Studio is installed, and…

View on GitHub

Drive DevOps Evolution 🔄💡

6. Digger

Digger is an open-source alternative to Terraform Cloud. It makes it easy to run terraform plan and apply in the CI / CD platform you already have, such as Github Actions.

⭐️ Digger on Github

diggerhq / digger

Digger is an open source IaC orchestration tool. Digger allows you to run IaC in your existing CI pipeline ⚡️

Community Slack | Schedule a call | Demo Video | Docs

CI/CD for Terraform is tricky. To make life easier, specialised CI systems aka TACOS exist - Terraform Cloud, Spacelift, Atlantis, etc.

But why have 2 CI systems? Why not reuse the async jobs infrastructure with compute, orchestration, logs, etc of your existing CI?

Digger runs terraform natively in your CI. This is:

Secure, because cloud access secrets aren't shared with a third-party
Cost-effective, because you are not paying for additional compute just to run your terraform

Features

Terraform plan and apply in pull request comments
Private runners - thanks to the fact that there are no separate runners! Your existing CI's compute environment is used
Open Policy Agent (OPA) support for RBAC
PR-level locks (on top of Terraform native state locks, similar to Atlantis) to avoid race conditions across multiple PRs
Terragrunt, Workspaces, multiple Terraform versions, static analysis…

View on GitHub

7. Logstash

Logstash is a free and open server-side data processing pipeline that ingests data from a multitude of sources, transforms it, and then sends it to your favorite "stash".

It's developed by Elastic, a name that anyone would like to add to their resume.

⭐️ Logstash on Github

elastic / logstash

Logstash - transport and process your logs, events, or other data

Logstash

Logstash is part of the Elastic Stack along with Beats, Elasticsearch and Kibana. Logstash is a server-side data processing pipeline that ingests data from a multitude of sources simultaneously, transforms it, and then sends it to your favorite "stash." (Ours is Elasticsearch, naturally.). Logstash has over 200 plugins, and you can write your own very easily as well.

For more info, see https://www.elastic.co/products/logstash

Documentation and Getting Started

You can find the documentation and getting started guides for Logstash on the elastic.co site

For information about building the documentation, see the README in https://github.com/elastic/docs

Downloads

You can download officially released Logstash binaries, as well as debian/rpm packages for the supported platforms, from downloads page.

Need Help?

Logstash Plugins

Logstash plugins are hosted in separate repositories under the logstash-plugins github organization. Each plugin is a self-contained Ruby…

View on GitHub

8. GO Feature Flag

This one is for those looking to get some Golang experience!

Feature flags let you modify system behavior without changing code. Reduce risk by releasing your features progressively.

⭐️ GO Feature Flag on Github

thomaspoignant / go-feature-flag

GO Feature Flag is a simple, complete and lightweight self-hosted feature flag solution 100% Open Source. 🎛️

🎛️ GO Feature Flag

🙏 If you are using GO Feature Flag please consider to add yourself in the adopters list.
This simple act significantly boosts the project's visibility and credibility, making a substantial contribution to its advancement.

If you want to support me and GO Feature Flag, you can also become a sponsor.

What is GO Feature Flag?

GO Feature Flag is a lightweight and open-source solution that provides a simple and complete feature flag implementation.

The solution has been…

View on GitHub

9. bytebase

Bytebase is a Database CI/CD solution, you can say it's GitLab/GitHub for Database DevOps, built for developers, DBAs and platform teams.

⭐️ bytebase on Github

bytebase / bytebase

The GitHub/GitLab for database DevOps. World's most advanced database DevOps and CI/CD for Developer, DBA and Platform Engineering teams.

⚙️ Install • 📚 Docs • 💬 Discord • 🙋‍♀️ Book Demo

Different database development tasks

Multiple database systems

Unified process

Single tool

🪜

Change

Want to formalize the database change process but don't know how

Standard Operating Procedure (SOP) Standardize the database schema and data change process across different database systems, small or large tables and different tenants. SQL Review 100+ lint rules to detect SQL anti-patterns and enforce consistent SQL style in the organization. GitOps Point-and-click GitHub and GitLab integration to enable GitOps workflow for changing database.

🔮

Query

Want to control the data access but don't know how?

All-in-one SQL Editor Web-based IDE specifically for performing SQL specific tasks. Data Masking State-of-the-art column level masking engine to cover complex situations like subquery, CTE. Data Access Control Organization level policy to centralize the data access control.

🔒

Secure

Want to avoid data leakage, change outage and…

View on GitHub

Create SaaS Wonders 👨‍💻🎉

10. Novu

Novu is an open-source notification infrastructure built for engineering teams to help them build rich product notification experiences without constantly reinventing the wheel.

⭐️ Novu on Github

novuhq / novu

Open-Source Notification Platform. Embeddable Notification Center, E-mail, Push and Slack Integrations.

The open source notifications framework that makes it easy for developers to empower product teams

Novu is the easy button for developer teams that need to quickly integrate notifications into their application, and enable product teams to own notifications content and messaging

Explore the docs »
or
Create a free account »

Report a bug · Request a feature · Join our Discord · Roadmap · X · Contact us

⭐️ Why Novu?

Novu provides a unified API that makes it simple to send notifications through multiple channels, including Inbox/In-App, Push, Email, SMS, and Chat. With Novu, you can create custom workflows and define conditions for each channel, ensuring that your notifications are delivered in the most effective way possible.

✨ Features

🌈 Single API for all messaging providers (Inbox/In-App, Email, SMS, Push, Chat)
💅 Fully managed GitOps flow, deployed from your CI
🔥 Define workflow and step controls with…

View on GitHub

11. Wasp

Wasp (Web Application Specification) is a Rails-like framework for React, Node.js, and Prisma.

⭐️ Wasp on Github

wasp-lang / wasp

The fastest way to develop full-stack web apps with React & Node.js.

The fastest way to develop full-stack web apps with React & Node.js

Web page | Docs

Wasp (Web Application Specification) is a Rails-like framework for React, Node.js, and Prisma.
Build your app in a day and deploy it with a single CLI command!

Why is Wasp awesome

🚀 Quick start: Due to its expressiveness, you can create and deploy a production-ready web app from scratch with very few lines of concise, consistent, declarative code.
😌 No boilerplate: By abstracting away complex full-stack features, there is less boilerplate code. That means less code to maintain and understand! It also means easier upgrades.
🔓 No lock-in: You can deploy the Wasp app anywhere you like. There is no lock-in into specific providers; you have full control over the code (and can actually check it out in .wasp/ dir if you are interested ).

Features

🔒…

View on GitHub

Each project you choose to contribute to not only enhances your skillset but also leaves your unique imprint on the technology landscape.

And as important- Donating code will make you part of a community that thrives on collaboration, creativity, and forward-thinking.

Don't forget to like, comment and bookmark 🫡

🤖 Build an AI assistant with real-time web access in 100 lines of code using Python and GPT-4 🌍

Matan Abramovich — Mon, 20 Nov 2023 14:00:00 +0000

ChatGPT has definitely made me spoiled over the last year.
It is my go to tool for everything, from getting code snippets to making memes, EXCEPT for internet research.

I mean, here's this cutting-edge AI, but for some reason whenever I need it to grab some info off the web for me, I feel I'm having a conversation with a confused chimp 🤷‍♂️

Yesterday I decided that enough is enough, rolled up my sleeves and got to work. Enter my new project: an AI assistant that doesn't just sit there spitting out the few first Bing results at you.
We're talking real-time, up-to-the-minute web access.

And now I'll show you how to build it yourself

Just a quick word about Pezzo: It is the fastest growing open source LLMOps platform, and the only one built for full stack developers with first class TypeScript Support.

Like our mission? Check Pezzo out and give us a star. We're building for developers, by developers 🧙‍♂️

The setup

For best performance we will build this assistant with the newest GPT model gpt-4-1106-preview and Tavily API, both require an API key.

Getting the API keys

Tavily API is free up to 1,000 requests a month, you just need to register with your Google account. Click here for Tavily API key.
Get OpenAI API key here.

Project setup

Create a new folder and inside it make a main.py and a config.py files.
Install the latest OpenAI SDK ```

pip install --upgrade openai

- Install the Tavily SDK

pip install tavily-python


> How to fix `error: can't find Rust compiler` when installing Tavily:
> - Paste this in the terminal to install Rust.
> ```


curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
>

Than, paste this in the terminal to configure your shell to recognize the Rust compiler. ```

source $HOME/.cargo/env

Let's get to work!

Config file

We will save all of the API keys here and import them into the other file to be used. This is how your config.py should look like:



OPENAI_API_KEY= "OPENAI_API_KEY"
TAVILY_API_KEY = "TAVILY_API_KEY"

Main file

Imports and clients init

First, import all of the libraries we'll need and initialize clients with API keys.



import json
import time
from config import OPENAI_API_KEY, TAVILY_API_KEY
from openai import OpenAI
from tavily import TavilyClient

client = OpenAI(api_key=OPENAI_API_KEY)
tavily_client = TavilyClient(api_key=TAVILY_API_KEY)

Creating a new assistant

To keep the function creating the assistant simpler to understand we will create the assistant instructions in a separate variable and pass it to creation function.



assistant_instruction = """You an analyst specializing in open-source intelligence, 
Your role is to gather and analyze publicly available information for market research and competitive analysis. 
You will provide insights, trends, and data-driven answers.
Never use your own knowledge to answer questions.
Always include the relevant urls for the sources you got the data from.`
"""
assistant = client.beta.assistants.create(
    instructions=assistant_instruction,
    model="gpt-4-1106-preview",
    tools=[{
        "type": "function",
        "function": {
            "name": "tavily_search",
            "description": "Get information on recent events from the web.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "The search query to use. For example: 'Provide a competitive analysis of Open Source survey tools'"},
                },
                "required": ["query"]
            }
        }
    }]
)
```
### Real time internet access 
If you look closely at the creation function you can see I gave the assistant a tool to brows the web, lets add it in!
#### Tavily search
```py
def tavily_search(query):
    search_result = tavily_client.get_search_context(query, search_depth="advanced", max_tokens=8000)
    return search_result
```

#### Tavily output handler
```py
def submit_tool_outputs(thread_id, run_id, tools_to_call):
    tool_output_array = []
    for tool in tools_to_call:
        output = None
        tool_call_id = tool.id
        function_name = tool.function.name
        function_args = tool.function.arguments

        if function_name == "tavily_search":
            output = tavily_search(query=json.loads(function_args)["query"])

        if output:
            tool_output_array.append({"tool_call_id": tool_call_id, "output": output})

    return client.beta.threads.runs.submit_tool_outputs(
        thread_id=thread_id,
        run_id=run_id,
        tool_outputs=tool_output_array
    )
```
### Managing conversation 
The last thing we need to do is build a way for us to pass real time input to the assistant and a way to keep general track of what is going on. the code below does all of that. **To start the assistant just run the `main.py` file, the conversation will take place inside the terminal window. To end the conversation type `exit` in the terminal.**
```py
# Wait for a run to complete
def wait_for_run_completion(thread_id, run_id):
    while True:
        time.sleep(1)
        run = client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run_id)
        print(f"Current run status: {run.status}")
        if run.status in ['completed', 'failed', 'requires_action']:
            return run

# Print messages from a thread
def print_messages_from_thread(thread_id):
    messages = client.beta.threads.messages.list(thread_id=thread_id)
    for msg in messages:
        print(f"{msg.role}: {msg.content[0].text.value}")


assistant_id = assistant.id
print(f"Assistant ID: {assistant_id}")

# Create a thread
thread = client.beta.threads.create()
print(f"Thread: {thread}")

# Conversation loop
while True:
    user_input = input("User input: ")
    if user_input.lower() == 'exit':
        break

    # Create a message
    message = client.beta.threads.messages.create(
        thread_id=thread.id,
        role="user",
        content=user_input,
    )

    # Create a run
    run = client.beta.threads.runs.create(
        thread_id=thread.id,
        assistant_id=assistant_id,
    )
    print(f"Run ID: {run.id}")

    # Wait for run to complete
    run = wait_for_run_completion(thread.id, run.id)

    if run.status == 'failed':
        print(run.error)
        continue
    elif run.status == 'requires_action':
        run = submit_tool_outputs(thread.id, run.id, run.required_action.submit_tool_outputs.tool_calls)
        run = wait_for_run_completion(thread.id, run.id)

    # Print messages from the thread
    print_messages_from_thread(thread.id)
```

This is what you should see in the terminal when running this file, the assistant is up and waiting for your input-
```
Assistant ID: asst_niCFSyEx6EVq1IQ32byEjLDn
Thread: Thread(id='thread_VjKfyeGpVWII05bALc1Arxdk', created_at=1700259453, metadata={}, object='thread')
User input: how can you help?
Run ID: run_46vRzPA40BPXaZ4Y68qSzuRn
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: in_progress
Current run status: completed
assistant: As an open-source intelligence analyst, I can assist you by gathering and analyzing publicly available information to provide insights on various topics. This can include but is not limited to:

1. Market research: Compiling data on market trends, consumer behavior, industry analysis, and competitive landscapes.
2. Competitive analysis: Comparing products, services, and strategies of competitors within a market.
3. Technology tracking: Monitoring developments in technology, new product releases, and innovations.
4. Event tracking: Keeping up to date with recent events, announcements, and news related to specific industries or topics.
5. Sentiment analysis: Analyzing public opinion and sentiment towards brands, products, or topics on social media and other online platforms.

Based on the task at hand, I can utilize various tools available to me, such as running searches for recent events or conducting tailored research using specific queries.

Let me know how I can assist you today!
User input:
```

---

![end, remote](https://media.giphy.com/media/xUPOqo6E1XvWXwlCyQ/giphy.gif)

That's All Folks!

I've tested this assistant vs. chatGPT and this one is so much better! 
Now make your on spin on this- play around with it and let me know all the ways you find to make the most of this 💪

🤫 A Secret Technique To Sidestep LLM Hallucinations [With Examples]

Matan Abramovich — Thu, 09 Nov 2023 13:30:00 +0000

Ever chatted with an AI and gotten a response so out there, it felt like it came from a parallel universe?

LLMs (like all of us) occasionally have day-dreams, also known as "hallucinations".

Stick with me, and I'll show you a quick and easy fix to prevent this from happening to the product you're working on.

Different Types of Hallucinations:

The Obvious Untruths:

An AI just told you about a president who never existed.
The LLM has made up events, people, and places that are as real as unicorns, entertaining, but not exactly helpful when you're after the facts.

The Oversharer:

In contrast to making things up, some LLM responses go overboard with details. Before you know it, a user gets access to information it shouldn't have. It raises concerns about privacy and the ethical use of data.

The Gibberish Generator:

And sometimes, it's like they just smash the keyboard and hope for the best, similar to a baby with alphabet soup. Not what you want if this output is fed to another function.

Just a quick word about Pezzo: It is the fastest growing open source LLMOps platform, and the only one built for full stack developers with first class TypeScript Support.

Like our mission? Check Pezzo out and give us a star. We're building for developers, by developers 🧙‍♂️

Why Do Hallucinations Happen?

The Desire to Please:

LLMs hate letting us down. When faced with gaps in data, it may invent details to fulfill the user's request, prioritizing continuity over accuracy.

Outdated Information:

An LLM's knowledge can be outdated. In fact, it is only as current as its last update. This can lead to hiccups in their responses.

Preventing Hallucinations With "Sanity Checks"

Sanity Checks are our way of teaching AIs to pause and ponder before blurting out whatever comes to mind. It's like giving them an internal filter to weed out the wacky before it hits our screens.

This is how you do it: Add to your prompt an example of a thinking process where you stop after every response and perform a check about that response. The subject doesn't matter, the LLM will follow the reasoning structure. You can copy and paste this example to your prompt:

Question: Who lived longer, Albert Einstein or Isaac Newton?

Answer:
Are follow up questions needed here: Yes.
Follow up: How old was Albert Einstein when he died?
Intermediate answer: Albert Einstein was 76 years old when he died.
Follow up: How old was Isaac Newton when he died?
Intermediate answer: Isaac Newton was 84 years old when he died.
So the final answer is: Isaac Newton.

The Evolution of Prompting

This prompting technique is a natural evolution from Direct Prompting and Chain-Of-Thought Prompting (see pic below). Here's the cool part: Sanity Checks Prompting reveals the LLM's thought process, letting us peek into the "black box" as it breaks down complex queries into bite-size follow-ups. The LLM knows it's reached the destination when it can seamlessly transition from intermediate answers to a final, confident conclusion.

Direct Prompting vs Chain-Of-Thought Prompting from the article linked at the bottom

AI hallucinations are a fixable glitch, not a dead end, and you're now ready to tackle them head-on.
Take these tools, push the AI to its limits, and make it work for you.

If there's a specific bug you can't iron out with your AI, let's hear it below. Your challenge might just be the star of our next troubleshooting guide.
Go on, give it a whirl and report back 🚀

This article is inspired by the paper Measuring and Narrowing the Compositionality Gap in Language Models

6 AI Tools You Have To Know as a Software Developer! 🛠 🤯

Matan Abramovich — Wed, 01 Nov 2023 12:30:00 +0000

AI is totally changing the game for software developers these days. There are some crazy cool AI tools out there that can seriously level up any programmer's workflow.

These AI tools aren't just nice extras, they can be total game-changers for modern development work. Any developer looking to step up their game should seriously consider integrating these AI capabilities into their process.

Of all the useful AI tools that exist today, here are six that standout among the crowd that every developer should absolutely have on their radar.

1. ai-shell 💬

What it does: ai-shell is an open-source CLI tool that translates natural language into shell commands. Think of it as having a conversation with your terminal, where you describe what you want, and it provides the relevant command.

Who is it for: Developers unfamiliar with specific shell commands or those who prefer a more intuitive interaction with the terminal.

Website: https://github.com/BuilderIO/ai-shell

2. Cursor 💻

What it does: Cursor integrates AI directly into the coding process, helping in various tasks. It assists in code changes, bug spotting, debugging, and even offers a chat feature to ask questions about your codebase.

Who is it for: Developers seeking an enhanced coding experience with the power of AI. Or if you want to experience some magic in your IDE, honestly- I just love watching it go.

Website: https://cursor.sh

3. v0 🎨

What it does: Imagine being able to craft UI components with just a simple text prompt. v0 makes this a reality, allowing developers to swiftly generate a range of UI elements, from chat interfaces to dashboards.

Who is it for: Front-end developers and UI/UX designers looking for a quick design solution.

Website: https://v0.dev

4. Pezzo ⚙️

What it does: Pezzo is a cloud-native LLMOps platform for building, monitoring, optimizing, and deploying AI features. It offers prompt management, troubleshooting capabilities, and instant prompt changes delivery.

Who is it for: Developers who work with language models and seek a unified platform for AI operations with first class TypeScript Support.

Website: https://github.com/pezzolabs/pezzo

5. Tolgee 🌐

What it does: Tolgee streamlines the software localization process, making it easier for developers to offer their applications in multiple languages. It offers in-context translating, one-click screenshots, and integrates with various other tools.

Who is it for: Developers working on a product with a global audience and wanting an efficient tool for software translation and localization.

Website: https://github.com/tolgee/tolgee-platform

6. Formbricks 📝

What it does: Formbricks is an open-source survey toolbox designed for creating in-product micro-surveys. It's a powerful tool to gather insights from users, enhancing the product's user experience.

Who is it for: Product managers and developers keen on understanding their users' needs and enhancing product experience.

Website: https://github.com/formbricks/formbricks

These tools are just the tip of the iceberg, and as AI continues to advance, I'm sure even more groundbreaking tools will emerge in the near future. So, stay curious and keep exploring! 🚀

Build an AI Powered Moderation System in Under 10 Minutes Using JavaScript

Matan Abramovich — Mon, 30 Oct 2023 12:30:00 +0000

Inappropriate or abusive content online can be a major headache. As a developer, you may have struggled with building effective content moderation into your applications. Manual moderation simply doesn’t scale. But what if you could quickly implement an AI-powered moderation system to automatically detect and filter out toxic comments?

In this guide, you'll learn how to leverage OpenAI's API to build a simple yet robust moderation system in under 10 minutes. Whether you're working on a social platform, forum, or any user-generated content site, you can easily integrate this into your stack.

Pezzo: Open-Source LLMOps Platform 🚀
Just a quick background about us. Pezzo is the fastest growing open source LLMOps platform, and the only one built for full stack developers with first class TypeScript Support.

Like our mission? Check Pezzo out and give us a star. We're building for developers, by developers 🌟.

Getting set up

Getting an OpenAI API key

First you’ll need to sign up at OpenAI and obtain an API key. Once obtained, make sure you set it as an environment variable (OPENAI_API_KEY).

Setting up the project

Create an app.ts somewhere in your file system. Initialize a new NPM project (npm init -y) and make sure to install the OpenAI client (npm i openai). You should be good to go!
For an in-depth guide on how OpenAI API works check out this post.

Let's start simple

We're going to start by writing a simple prompt. We'll have a system message that provides guidelines for moderation, and a user message that contains the users's input (imagine this comes from a UI of some sort). Here's a code example:

import OpenAI from "openai";

const openai = new OpenAI();

const response = await openai.chat.completions.create({
  model: "gpt-3.5-turbo",
  temperature: 0,
  messages: [
    {
      role: "system",
      content: "is this text inappropriate?"
    },
    {
      role: "user",
      content: "You are such an idiot! Only a moron would think that way. People like you don't deserve to have an opinion with such stupid ideas. Do everyone a favor and keep your dumb thoughts to yourself."

    }
  ],});

AI response:

{
  id: 'chatcmpl-8F9sKbcaPkWUJSc9gv3M1LBqGJmzf',
  object: 'chat.completion',
  created: 1698623572,
  model: 'gpt-3.5-turbo-0613',
  choices: [ { index: 0, message: [Object], finish_reason: 'stop' } ],
  usage: { prompt_tokens: 61, completion_tokens: 33, total_tokens: 94 }
}
[
  {
    index: 0,
    message: {
      role: 'assistant',
      content: 'Yes, this text is inappropriate. It contains insults, name-calling, and derogatory language. It is disrespectful and does not promote healthy communication or constructive dialogue.'
    },
    finish_reason: 'stop'
  }
]

Let's break this down:

The user message is: "You are such an idiot! Only a moron would think that way. People like you don't deserve to have an opinion with such stupid ideas. Do everyone a favor and keep your dumb thoughts to yourself."

The system message is: "is this text inappropriate?"

The AI response: Yes, this text is inappropriate. It contains insults, name-calling, and derogatory language. It is disrespectful and does not promote healthy communication or constructive dialogue.

Better moderation granularity

Simply understanding if the text is inappropriate isn't enough. We want to understand what's inappropriate about it.

We can guide the AI to be more granular, and categorize its response Toxicity, Hate Speech or Threats.

Toxicity covers rude, disrespectful comments. Hate speech involves racist, sexist or discriminatory language. Threats are violent, harmful statements.

(For ethical reasons, this guide will not include examples of actual hate speech or threats - but the concepts can be applied to address these policy violations.)

messages: [
    {
      role: "system",
      content: "Lable this text as: Toxicity - Rude, disrespectful comments OR Hate Speech - Racist, sexist, discriminatory OR Threats - Violent threats"
    },
    {
      role: "user",
      content: "You are such an idiot! Only a moron would think that way. People like you don't deserve to have an opinion with such stupid ideas. Do everyone a favor and keep your dumb thoughts to yourself."

    }
  ]

AI response:

{
  id: 'chatcmpl-8FAUdmvD2yECuhbbKGgRX6d1MgO5J',
  object: 'chat.completion',
  created: 1698625947,
  model: 'gpt-3.5-turbo-0613',
  choices: [ { index: 0, message: [Object], finish_reason: 'stop' } ],
  usage: { prompt_tokens: 84, completion_tokens: 9, total_tokens: 93 }
}
[
  {
    index: 0,
    message: {
      role: 'assistant',
      content: 'Toxicity - Rude, disrespectful comments'
    },
    finish_reason: 'stop'
  }
]

Now the AI response is now more granular. In a real-world app, this will allow us to take different automatic moderation actions based on the type violation.

Stricter instructions via system prompts

We can achieve stricter and more accurate results by utilizing the system message. In short - LLMs behave the way they are trained. We'll apply some prompt engineering techniques to guide the AI to behave the way we want.

In the example below, we:

Assign a role to the AI - Content Moderator
State a clear task to be achieved
Define a limited set of results and criteria for each

 messages: [
    {
      role: "system",
      content: "Your role is to act as a content moderator for an online platform. Your task is to label comments as 'Toxicity', 'Hate Speech', or 'Threats' based on if they contain rude, discriminatory, or threatening language. Use the following criteria: Toxicity - Rude, disrespectful, overly negative comments, Hate Speech - Racist, sexist, homophobic, discriminatory language, Threats - Violent, graphic, or directly harmful statements"
    },
    {
      role: "user",
      content: "You are such an idiot! Only a moron would think that way. People like you don't deserve to have an opinion with such stupid ideas. Do everyone a favor and keep your dumb thoughts to yourself."

    }
  ]

AI response:

{
  id: 'chatcmpl-8FBP8kRFB5NTuhspJLQAbDwZDdJXQ',
  object: 'chat.completion',
  created: 1698629450,
  model: 'gpt-3.5-turbo-0613',
  choices: [ { index: 0, message: [Object], finish_reason: 'stop' } ],
  usage: { prompt_tokens: 145, completion_tokens: 3, total_tokens: 148 }
}
[
  {
    index: 0,
    message: { role: 'assistant', content: 'Toxicity' },
    finish_reason: 'stop'
  }
]

The AI's accuracy has improved. It is now able to distinguish between specific violation types.

There is a trade-off: more detailed instructions require more tokens upfront, but enable more precise results.

While elaborate prompts cost more tokens, the benefits taper off eventually. The key is optimizing prompts to be just as informative as needed - not as long as possible. We want to give the AI sufficient guidance without diminishing returns on token efficiency.

Additionally, too many tokens (or words) in the messages will result in potential hallucinations by the AI (in short, AI making things up).

Did you know? There is a way to getting better results form an AI model that IS cheaper. Let me know in the comments if you want me to write a post about it 👇

Structured JSON responses

The AI returns human-readable text, which is not very useful. Let's see how we can easily retrieve a JSON response, so that the result is processable. This is useful if you want to render the result in a user interface, or store it in a database.

It's as simple as adding one line to our system prompt!
Here it is:

You must respond in JSON, always following this schema: 

{
  label: string[];
}

messages: [
    {
      role: "system",
      content: "Your role is to act as a content moderator for an online platform. Your task is to label comments as 'Toxicity', 'Hate Speech', or 'Threats' based on if they contain rude, discriminatory, or threatening language. Use the following criteria: Toxicity - Rude, disrespectful, overly negative comments, Hate Speech - Racist, sexist, homophobic, discriminatory language, Threats - Violent, graphic, or directly harmful statements.

You must respond in JSON, always following this schema:

{
  label: string[];
}
"
    },
    {
      role: "user",
      content: "You are such an idiot! Only a moron would think that way. People like you don't deserve to have an opinion with such stupid ideas. Do everyone a favor and keep your dumb thoughts to yourself."

    }
  ]

AI response:

{
  id: 'chatcmpl-8FBkEFCJMQVpWIWQoR6Zho53k0DoU',
  object: 'chat.completion',
  created: 1698630758,
  model: 'gpt-3.5-turbo-0613',
  choices: [ { index: 0, message: [Object], finish_reason: 'stop' } ],
  usage: { prompt_tokens: 165, completion_tokens: 8, total_tokens: 173 }
}
[
  {
    index: 0,
    message: { role: 'assistant', content: '{"label": ["Toxicity"]}' },
    finish_reason: 'stop'
  }
]

6 Go-To Techniques to Master AI's Hidden Language: My Playbook for Winning the AI Chat Game

Matan Abramovich — Mon, 16 Oct 2023 16:40:52 +0000

Have you ever tried asking Siri to recommend a good takeout place, only to get a list of web search results?
Or perhaps you eagerly queried ChatGPT about the latest AI advancements, but got an incoherent mess of text back.
I've been there too! That was me before discovering the art of prompt engineering.

Imagine how much easier life would be if Siri could actually hold a conversation and make personalized recommendations.
Or if ChatGPT could engage intelligently on niche topics. Prompt skills let you make that AI dream a reality!

Why This Should Be On Your Radar

Here are 3 big benefits I've experienced:

More productive workflows. Now I can get ChatGPT to generate great content fast with the right prompts.
Improved home life. My new prompt-savvy smart speaker actually gives me solid advice now like a virtual buddy!
Next-level tech skills. I've become the AI whisperer among my friends. Talk about street cred!

The Secret Sauce: 6 Go-To Prompt Engineering Techniques

Through much trial and error, I've identified 6 techniques that transform my AI conversations:

1. Chain-of-Thought Prompting

How It Works: Break down complex instructions into easy step-by-steps.

Real-World Example: Cooking bots serve up way better recipes when I prompt them to lay out each step individually.
No more massive, confusing blocks of text!

Sample Prompts:

"Walk me through baking chocolate chip cookies from start to finish in simple, clear steps"
"Explain how to change a bike tire one step at a time"

2. Generated Knowledge Prompting

How It Works: Give bots background info to complete tasks.

Real-World Example: Now my travel assistant tells me cool historical facts about landmarks before discussing them.
Almost like having a tour guide!

Sample Prompts:

"Give a 2-3 sentence intro to Picasso before analyzing his paintings"
"Provide context about D-Day before explaining the events"

3. Least-to-Most Prompting

How It Works: Start with simple aspects before complex ones.

Real-World Example: For recipes, I list ingredients/tools first so the instructions make more sense.

Sample Prompts:

"List ingredients and tools for chocolate chip cookies, then give step-by-steps"
"Give 3 plot points in Romeo and Juliet before summarizing the full story"

4. Self-Consistency Decoding

How It Works: Generate multiple responses and pick the best.

Real-World Example: Now translations sound much more legit in any language!

Sample Prompt:

"Translate 'She loves traveling' into Spanish 3 ways, then analyze and choose the most accurate"

5. Complexity-Based Prompting

How It Works: Get nuanced, multi-faceted responses.

Real-World Example: My Spotifybot makes personalized playlists with songs tailored to my ever-changing moods.

Sample Prompt:

"Suggest a dinner playlist with happy folk songs, somber jazz, and peaceful classical"

6. Self-Refine

How It Works: Have bots critique and improve their own work.

Real-World Example: I had an AI write a website bio of me, critique its tone/content, and refine it. Work smarter not harder!

Sample Prompt:

"Write a professional LinkedIn summary for me, then give feedback on how to improve it"

Now It's Your Turn to Chat with Bots

There you have my best tips for prompt engineering!

With time and practice, you'll be able to effortlessly chat about complex topics with AI.
Try incorporating one of these techniques next time you ask chatGPT for help. Share your victories with us on @Pezzo.ai.

Now get out there and show those bots who's boss with your new conversation skills!