Most generative AI tools involving video, audio, or images still follow a very linear workflow. You generate some text, move it to another tool to record audio, then manually edit and assemble the final asset. AI helps with the pieces of the process, but it rarely participates in the full creative workflow.

SceneOne Studio was designed to change that.

The idea was simple: build a system where an AI agent can see a product, guide a short recording session, and produce a finished audio clip in one continuous interaction.

Instead of a text generator, the AI becomes the creative director that guides the user and manages the production pipeline.

The Goal: Moving beyond prompt-only AI

Traditional AI tools operate inside a text box. They respond to prompts but have no awareness of the surrounding environment.

If someone wants to generate a short advert for a product, the process usually looks like this:

Step 1: Write a prompt describing the product

Step 2: Generate a script

Step 3: Copy the script to an audio tool

Step 4: Record voice audio

Step 5: Manually edit and trim the recording

Step 6: Export the final asset

The AI participates in steps one and two, but everything else is manual. SceneOne Studio was built to remove those gaps.

In this system, the user simply holds up a product to their camera. The AI analyses the object, generates a short script, guides the recording session, and produces a finished audio ad.

To support that workflow, the AI needs more than text input. It needs live audio, video, and the ability to interact with the interface.

Phase 1: Capturing live audio and video

The first technical challenge was ingesting the user’s camera and microphone in real time.

The frontend is built with Next.js and uses the browser's MediaDevices API to access the webcam and microphone. Video frames and audio chunks are captured continuously during a session.

These streams are then sent to the backend using a persistent Websocket connection.

The backend is built with FastAPI and acts as the central processing hub. Incoming media streams are forwarded to the Gemini model using the Google Agent Development Kit (ADK).

The ADK runner provides a run_live interface that allows Gemini to receive streaming input from the WebSocket connection.

Once this pipeline was working, the model could analyse what the user was showing on the camera during the session. That opened the door for real multimodal interaction.

Phase 2: Building the AI “Director”

With live input working, the next step was defining the agent itself. Using Google ADK, I created a custom SceneOne director agent that guides the session. The agent receives camera and microphone input, interprets the product being shown, and decides when to generate an ad script.

The agent is configured with system instructions that define its role as a creative director during the session. In my tests and experimentation with various products, the agent was intelligent enough to recognise any product that I presented. It went even as far as to notice textures, graining, colour gradients, contrasts, and even scuff marks.

I tested the live agent using a Volkano Bluetooth speaker, a Hush Puppie boot that's older than ten years, and a Kiwi and Tangarine Massage soap, and it recognised almost every detail in everytime each of those products.

At times when the product wasn’t very clear to the agent, it requested that I hold up the item closer to the camera, so it could take a closer look at the item.

Rather than constantly generating responses, the agent waits for the right moment in the interaction. When the user indicates they are ready, the agent generates a short ad script, which is usually 10 seconds in length. But the user has the option of toggling between 10 seconds to 30 seconds in the user interface.

Instead of simply returning the script as text, the agent triggers a tool call: capture_ad_script. This tool records the generated script and signals that the session should move into the recording phase.

At this point, the AI is no longer just generating content; it is controlling the workflow.

Phase 3: Connecting the agent to the interface

The next challenge was connecting the backend actions to the browser interface. When the AI decides that recording should start, the frontend needs to react, automatically.

To handle this communication layer, I integrated Copilot Kit as an agent-to-UI bridge.

When the backend agent triggers the capture_ad_script tool, the event is sent through CopilotKit to the Next.js frontend.

The frontend listens for this action using a useCoPilotAction hook. The user, can speak the words; “Hey Director” to begin the session, and then “Action” to complete the session, after which the agent kicks off the recording process.

Once the action is received, the browser automatically starts recording the microphone using the MediaRecorder API. The interface updates to show that recording has begun.

From the users perspective, the AI is directing the session.

Phase 4: Processing the audio

After the recording finishes, the captured audio is sent to the backend for processing. Raw audio capture often contains silence, inconsistent levels, and abrupt start or stop artifacts. To produce a clean audio asset, the file goes through a processing step in the FastAPI backend.

Using the Pydub library and FFmpeg, the system performs several operations:

1. Audio normalization adjusts the volume levels for a consistent output.
2. Silence detection identifies and removes dead air at the start or end of the recording.
3. Short fades are applied to prevent clicks at the beginning or end of the file.
4. Once processed, the audio is exported as a finalised “.wav” file.

Phase 5: Asset storage and retrieval

After processing, the finished audio is saved and made available to use. The backend returns a download URL to the frontend. The interface then adds a new card to the Asset Dock, which displays the generated script and provides a download link for the audio file.

SceneOne also supports optional persistence through Google Cloud Storage. Generated assets can be uploaded to a GCS bucket, so they remain available across sessions.

This ensures that the system can function as a live demo and as a persistent creative tool.

Final result: A multimodal creative workflow

SceneOne Studio demonstrates how multimodal AI systems can participate in real production workflows rather than acting as isolated text generators. The system combines several components:

The frontend captures live audio and video output.

The backend streams this data to Gemini through the ADK runtime. A custom agent analyzes the session and directs the creative process.

Audio processing tools refine the recording into a finished asset. Cloud storage ensures that the final output is available immediately.

Together, these pieces create a closed creative loop where a user can show a product, generate a script, record a voiceover, and receive a polished audi ad within a single session.

For the Gemini Live Agent Challenge, SceneOne represents a step toward AI systems that participate directly in creative production instead of simply generating text.

President Biden’s recent Executive Order underscores the significance of responsible and ethical AI adoption. In this order, the administration emphasizes the importance of taking the lead in both harnessing the potential and managing the risks associated with Artificial Intelligence (AI). Let’s break down the key points of this pivotal directive and what it means.

Ensuring AI Safety and Security

The Executive Order outlines the need for stringent standards in AI safety and security. This entails that developers of powerful AI systems must now share their safety test results and information with the government.

Furthermore, the order aims to establish standards and tools to ensure that AI systems are safe, secure, and trustworthy. It also emphasizes the critical importance of protecting against the risks posed by using AI to engineer potentially dangerous biological materials.

Safeguarding AI Privacy

With an eye toward protecting Americans’ privacy, the Executive Order urges Congress to pass bipartisan data privacy legislation.

It also directs actions to support the development and use of privacy-preserving techniques, strengthens privacy-preserving research and technologies, and ensures the evaluation of how agencies collect and utilize commercially available information.

Moreover, it advocates the development of guidelines to assess the effectiveness of privacy-preserving techniques.

Promoting AI Equity and Civil Rights

The order emphasizes the need to ensure that AI advances equity and civil rights. This includes providing clear guidance to prevent AI algorithms from exacerbating discrimination in crucial areas such as housing, federal benefits programs, and federal contracting.

Additionally, it underscores the importance of addressing algorithmic discrimination through training, technical assistance, and coordination between civil rights offices. The order also seeks to ensure fairness within the criminal justice system and emphasizes the need to enforce existing authorities to protect people’s rights and safety.

Protecting AI Consumers and Workers

Under this order, protecting consumers and workers is a top priority. It encourages the responsible use of AI in sectors like healthcare and education.

It also aims to develop principles and best practices to minimize the negative impacts of AI on workers while maximizing its benefits.

The order mandates the production of a comprehensive report on the potential impacts of AI on the labor market. It explores options for bolstering federal support for workers facing disruptions in their employment.

Fostering AI Innovation and Competition

To promote a fair and competitive AI landscape, the order aims to catalyze AI research across the United States. It also prioritizes providing small developers and entrepreneurs with access to technical assistance and resources through a pilot of the National AI Research Resource.

The order stresses the importance of aiding small businesses in commercializing AI breakthroughs and expanding opportunities for highly skilled immigrants and nonimmigrants with expertise in critical areas to contribute to the development and implementation of AI in the United States.

Leading Global Initiatives in AI

Recognizing the global impact of AI, the order calls for expanded collaboration with international partners. It aims to accelerate the development and implementation of essential AI standards and encourages the responsible and rights-affirming deployment of AI solutions globally.

Additionally, it seeks to support allies and partners in establishing a robust international framework for the development and use of AI.

Ensuring Responsible AI Deployment in Government

The Executive Order underscores the need for responsible AI deployment within the government and emphasizes the modernization of federal AI infrastructure.

It calls for issuing guidance for agencies’ use of AI and streamlining the acquisition of AI products and services through efficient contracting. Additionally, it aims to accelerate the hiring of AI professionals as part of a comprehensive government-wide AI talent surge.

How does this order affect businesses using AI?

The Executive Order issued by President Biden emphasizes the significance of responsible AI usage and offers a complete structure that companies using AI must comprehend. However, what are the wide-ranging consequences of this order for businesses?

Privacy Regulations and Compliance

For businesses that rely on AI to collect, process, or analyze personal data, the Executive Order introduces new privacy regulations and standards. This includes using privacy-preserving techniques and sharing relevant information with the government.

Moreover, it emphasizes the need for following guidelines to evaluate the effectiveness of privacy-preserving techniques. Compliance with these measures is essential to ensure the privacy and data security of individuals.

Ensuring Fair and Accountable AI

Businesses using AI to provide services impacting people’s rights, safety, or well-being should ensure fair, transparent, accountable, and non-discriminatory AI systems.

This involves providing clear guidance to prevent AI algorithms from exacerbating discrimination and addressing algorithmic discrimination through training and coordination efforts. It also emphasizes enforcing existing authorities to protect people’s rights and safety.

Ensuring fairness and accountability is not only a legal requirement but also a moral obligation for businesses.

Opportunities for Innovation and Global Competition

Businesses can leverage the Executive Order’s AI initiatives and resources for research, development, and commercialization.

This includes accessing technical assistance and resources and benefiting from the expanded ability of highly skilled immigrants and nonimmigrants with expertise in critical areas to study, stay, and work in the United States. These opportunities can help businesses stay at the forefront of AI-driven innovation and maintain a competitive edge.

Responsible Government Deployment

Businesses interacting with the government or providing services to the government must adapt to new guidance and standards for the responsible deployment of AI.

This entails using specified AI products and services that meet certain criteria. Furthermore, they should adhere to best practices for mitigating the potential harms and maximizing the benefits of AI for workers.

Collaboration with the government on developing vital AI standards with international partners is also encouraged. This ensures that AI systems used in government-related operations are aligned with ethical and responsible practices.

A Final Word(s)

President Biden’s Executive Order is a significant milestone in the journey toward responsible and ethical AI adoption. Businesses using AI must pay attention to the evolving landscape and adapt their practices accordingly. President Biden’s vision for AI is not just about government policy; it’s about creating a framework that benefits the entire AI community.

Call to Action

Know someone on the hunt for a top-notch development partner to bring their MVP dream to life? Connect them with me on LinkedIn — your referrals are the fuel that drives innovation! 🚀

You can also find me here on Github!

I’ve been delving deep into the fascinating world of Large Language Models (LLMs), and I can’t wait to share what I’ve learned with you.

Let me walk you through a framework that harnesses the power of LLMs to create advanced applications and agents.

It’s all about understanding the four fundamental stacks that make these models tick.

The LLM Stack

At the core of any LLM application lies the LLM stack. Whether you’re working with OpenAI’s GPT-4, ChatGPT 3.5, or LLaMA-2, this is where the magic begins.

You need to consider how the model was created, the pre-training, fine-tuning, and whether any Reinforcement Learning from Human Feedback (RLHF) has been applied.

Think about customizing and fine-tuning the model to suit your specific needs and optimizing its serving strategy. The LLM stack is the foundation upon which you’ll build your intelligent agent.

When using open source software in the LLM stack, it's important to consider the method of serving. Will you opt for cloud hosting?

If you are using LLaMA-2 in the cloud and paying per token, it is important to consider whether you will be paying by the amount of compute you use.

It may be worthwhile to think about running the process locally, using one of the four-bit models and a low-resolution model.

However, if you are looking to use LLM for more than just a simple chatbot and require logic or mathematics, full resolution models may perform better than quantization models.

The Search/Memory/Data Stack

The second stack is all about data. You’ll be dealing with semantic search and vector stores, making decisions about which tools and technologies to use.

Will you opt for Faiss or explore hosted solutions like ChromaDB or Pinecone?

You’ll also need to think about data access, extraction from conventional databases, and knowledge graphs.

Now, obviously, the language model that you’ve chosen will have a big impact on this. If you’ve gone for a language model with a 16K context window, now you can actually afford to inject a lot more into it.

Another key component of this stack is to consider aspects such as search functionality.

If you’re using Google or Duck Duck Go to go out and fetch information off the web or scrape that information from somewhere in real-time, that’s something that you also want to think about in this stack as well.

Finally, another key part that’s really key for building agents is the whole concept of memory of basically having some kind of memory that you can save to and retrieve from, for injecting information into your prompts via in context learning. So this is a key part of this stack as well.

This stack is all about connecting your LLM with the information it needs to provide valuable insights.

The Reasoning and Action Stack

As your application evolves, you’ll find yourself exploring the reasoning and action stack. This is where the decision-making happens, often with the help of your LLM.

Whether you’re using React or other tools, you need to consider the logic behind your system’s choices.

Remember that all the stacks interact with each other. So, if you are doing something with React or OpenAI functions or something like that, that would fit into this.

Mathematical and logic solvers can provide stability and structure, enhancing your application’s decision-making capabilities.

This stack will continue to grow as we explore new ways of reasoning beyond just LLMs.

The Personalization Stack

The top layer of this framework is all about personalization. This is where your application develops its unique personality, style, and brand.

You might be tracking user interactions or customizing the conversation’s tone.

Think of it as fine-tuning the output via prompts and other manipulations.

This is the level of the stack that people talk about and a lot more people have done really interesting experiments in trying to get a large language model to be like a certain personality or to act in a certain way and respond in a certain way.

Personalization is key if you want your LLM-powered agent to connect with users on a more personal level.

A Final Word

When designing your LLM application or agent, consider the importance of each of these stacks. If you’re aiming for rich, role-playing interactions, invest in personalization.

If data integration is central to your project, the search/memory/data stack is your focus. Each layer offers different tools and opportunities to make your application shine.

As you’re architecting your application, remember that it’s not just about where each stack fits but also how they interact. Your choices at each level will impact the final product.

Whether you’re creating a mobile app or a sophisticated agent, think carefully about your tools, reasoning, and the heuristics your agent uses for decision-making.

This framework will empower you to create LLM chat apps, summarization apps, and LLM agents that can tackle diverse tasks.

Each stack has its unique role in shaping your application, and understanding them will be your key to success.

If you’re as intrigued by this topic as I am, feel free to share your thoughts in the comments. And if you found this post valuable, let me know.

Stay tuned for more exciting updates in the world of Large Language Models. Bye for now!

Call to Action

Know someone on the hunt for a top-notch development partner to bring their MVP dream to life? Connect them with me on LinkedIn — your referrals are the fuel that drives innovation! 🚀

You can also find me here on Github!

Recently, I ventured out and experimented with hosting an open-source language model on my Windows laptop. Why would I do this, you might ask, if there already are options like GPT4, ChatGPT, PaLM, and others?

Well, there are a few reasons why I feel it is a good idea to host a small LLM locally.

Firstly, as a hard-core techie, it's a small project that is fun to explore, play around with, and get to understand how an LLM works. With hosting an open source LLM locally, you have the option to “look under the hood” at how a large language model works, and you can tinker with the settings, source code, and the different infrastructure options that you have available.

If you wanted to, you could also spin up a cloud server to host your language model in the cloud. But, if you’re only starting out and experimenting, you can get away with running a smaller model on your Windows / Mac.

Secondly, with a locally running language model, you have the option of fine-tuning the model on your own data.

If you’re part of a small enterprise, the costs of fine-tuning a proprietary model can become a costly affair.

If you have sensitive data that you do not want to be exposed to third parties, running an open-source, privately hosted language model is a significant benefit as your private data remains contained, and there are no risks of data leaks.

Furthermore, fluctuating vendor pricing makes it difficult to know for certain what your usage costs will be at the end of each billing cycle. However, you could set up hard and soft usage limits to avoid running into excessive costs on a proprietary model.

With proprietary language models, you are locked into a specific vendor, and there are limited options for flexibility. Thankfully, there are open source libraries available to enable a smooth transition from a proprietary model to an open source one.

Open source language models are getting better at providing better responses, as the open source community is making huge strides in improving the quality of outputs. However, in this aspect, proprietary models still have the upper hand, are far more accurate in their responses, and are improving daily. But there will come a time when open source models will catch up (and maybe even surpass) proprietary models.

With that being said, let's dive into the nitty-gritty of setting up and running your very own language model hosted on your personal laptop/PC. The steps for setting up an LLM locally are simple and straightforward, but it does require technical expertise and know-how to set up and configure.

Setting up WebUI for Text Generation

Currently, there are several open source language models that you could experiment with. A few open source models that are worth mentioning include Orca, Mistrel, and Falcon.

You can look up the technical specs for each of these open source models on Huggingface to learn more. Here are the links for some of these Huggingface models:

• pankajmathur/orca_mini_13b · Hugging Face
• TheBloke (Tom Jobbins)
• TheBloke/MistralLite-7B-GPTQ · Hugging Face

The first step is to set up the WebUI interface. This interface allows you to interact with, configure, and fine-tune the language model according to your needs. You can access the Github repo for WebUI at this link;

GitHub - oobabooga/text-generation-webui: The definitive Web UI for local AI, with powerful features and easy setup.

The Github repository offers comprehensive installation instructions to get you up and running with the WebUI interface in no time. There are ‘one-click’ options available to download and extract ZIP files to your local drive.

There is also an option to run the Docker version of the WebUI interface if you prefer installing it this way. I personally haven’t experimented with using Docker for this experiment but maybe I might give this a try at a later stage.

I opted to clone the Gihub repo instead and set up the UI from there. If you’re going to clone the Github repo, I recommend that you do it in a Conda environment.

I am doing the setup from my Windows laptop and have Anaconda installed, so the Conda terminal comes pre-installed. I would not recommend using a regular Windows terminal. Open up a Conda terminal, as shown in the image below.

From your Conda terminal, enter the following command:

conda create -n tui python=3.10.9

Here, we are specifying the name of the Python environment, “tui,” and the Python version. In this case, we are using Python version 3.10.9.

When you are promoted to Proceed, type in “y” or hit Enter since “y” is the default option.

When the setup completes successfully, you will see the following screen:

Type in ‘conda activate tui’ to activate the Conda environment. Your command prompt will now change to “tui” to show that you are in your new Python environment. The next step is to install the Python packages that WebUI requires. At your terminal, enter the following line;

pip3 install torch torchvision torchaudio — index-url https://download.pytorch.org/whl/cu117

The next step is to clone the Github repository. The link for the WebUI Github repo is:

GitHub - oobabooga/text-generation-webui: A Gradio web UI for Large Language Models. Supports transformers, GPTQ, AWQ, llama.cpp (GGUF), Llama models.

At your Conda terminal, type in:

“git clone https://github.com/oobabooga/text-generation-webui.git”

After cloning the Git repo, you’ll need to install all the Python modules for the repository. At your terminal, enter in:

pip install -r requirements.txt

Since you are using a Conda Python environment, you won’t run into any dependency issues while doing a `pip install.`

If you are using an NVIDIA GPU, there's an additional step that is required. For Linux, run the following command:

For Windows, run the following command:

If you are just working on a CPU and you don’t want to run these models on your GPU, you can skip the steps above.

My laptop does not have a GPU, so I skipped the steps above. Now that you’ve installed all the dependencies, the only thing that is left is to start up your server, which you can do by typing in the following command at your terminal:

python server.py

Copy the URL provided, and paste it into your Chrome browser, to start up the WebUI interface, which will look like the image below:

Once you have the WebUI interface running, you will need to hook it up to an open source language model. There are three different ways in which you can do this.

The first method is by downloading the Huggingface model directly from the WebUI interface.

As I mentioned above, there are several open source models for you to choose from. For the purposes of my experiment, I initially chose to use the Mistral-7b model, which wasn't the best option since I later discovered that WebUI does not support the Mistral models yet.

You are free to experiment with any open source model. With so many available, you are not limited to using any specific model. However, as a first start, I recommend that you start with using the orca_mini_13b.

Copy the link to the Huggingface model, and paste it into your WebUI interface. Go to the Models tab in WebUI, and paste in the link to the Huggingface model. Click the Download button when you are ready to begin downloading the model.

The second method for downloading the Huggingface model is to download it from the Conda terminal using the following command:

python download-model.py pankajmathur/orca_mini_13b

In the command above, I have pasted the link to the Huggingface model to download the Orca mini 13b model.

The final method of downloading a Huggingface model is doing it all manually, which is not the most ideal option, as it can lead to unnecessary issues and frustrations. If you want to follow this method, open the link to the Huggingface model in your web browser, and navigate to the “Files and Folders” tab

Then, download each of the files individually, and copy them into the models folder in your text-generation-ui project.

Once you’ve successfully installed the model, go back into the WebUI interface and apply the model that you have downloaded in the Model tab.

And that is all that is needed for setting up the WebUI interface and configuring an open source model!

There are additional settings that you could configure to optimize your environment. For example, if you are using a CPU, you can toggle the “cpu” option.

What's nice about using WebUI is that you can fine-tune the model on your own data. I have not yet explored this option as yet, as I am still familiarising myself with the interface and exploring different models etc. You can access the fine-tuning option by navigating to the “Training” tab of the WebUI interface.

A benefit of hosting an open source language model on your local PC is that you have access to an LLM even when there is no internet access available. So if you are traveling by train, bus, or airplane without internet access, you still have the ability to perform text generation tasks from your local LLM.

I hope this post has helped you with experimenting with open source models and got you interested in further developing applications with large language models!

Note: All the open source language models that I have mentioned in this article are only meant for text generation.

Call to Action

Know someone on the hunt for a top-notch development partner to bring their MVP dream to life? Connect them with me on LinkedIn — your referrals are the fuel that drives innovation! 🚀

You can also find me here on Github!

In the world of software development, contributing to open source projects is not only a way to give back to the community but also a fantastic opportunity to enhance your skills, collaborate with like-minded individuals, and make a meaningful impact.

However, finding the right open source project to contribute to can be a daunting task. In this article, we will explore some effective strategies and platforms that will help you discover exciting open source projects and help you with making valuable contributions to the projects you love 💛

Define Your Interests and Goals

Before diving into the vast sea of open source projects, take a moment to reflect on your interests, skills, and goals. Identify the programming languages, frameworks, or domains you enjoy working with.

This self-reflection will serve as a compass to guide your search and ensure that you find projects that align with your passions.

Leverage GitHub

GitHub is a goldmine for open source projects, and it offers numerous features to help you find suitable projects to contribute to. Start by exploring the “Explore” section on GitHub, where you’ll find trending repositories, curated collections, and topics that pique your interest.

Additionally, use the GitHub search bar to find projects based on keywords, programming languages, or specific topics.

Explore Open Source Directories

Open source directories are treasure troves of diverse projects actively seeking contributions. These directories compile and categorize open source projects, making it easier for developers to discover projects aligned with their interests and expertise.

Open Source Friday

Open Source Friday is a platform that promotes open source contributions by encouraging developers to dedicate time each Friday to work on open source projects.

The platform features a curated list of projects from various domains, programming languages, and difficulty levels. It’s an excellent starting point for developers who want to explore different projects and contribute regularly.

Awesome Open Source

Awesome Open Source is a community-curated list of open source projects spanning a wide range of domains, including web development, machine learning, mobile apps, and more.

The platform showcases projects based on popularity, relevance, and community recommendations. Developers can filter projects by programming language, stars, forks, and other criteria, making it easier to find projects that match their preferences.

Up For Grabs

Up For Grabs is a website specifically designed to connect open source projects with contributors. It lists projects with open issues or tasks suitable for newcomers.

These projects often tag their issues as “up-for-grabs” or “good-first-issue,” indicating that they welcome contributions from developers with little or no prior experience with the project.

It’s a fantastic resource for developers who want to dip their toes into open source contributions and gain hands-on experience.

CodeTriage

CodeTriage is another platform that helps developers find open source projects in need of active maintainers and contributors.

The platform allows you to subscribe to projects of interest, and you’ll receive a curated list of issues via email.

This ensures that you stay up to date with projects you care about and have a steady stream of potential contributions to work on.

Language-Specific Directories

Many programming languages have their own dedicated directories for open source projects. For example, Ruby developers can explore RubyGems, a repository of Ruby libraries and applications.

Similarly, Python developers can check out PyPI, the Python Package Index, which hosts a vast collection of Python packages and projects.

These language-specific directories provide a focused approach to finding projects tailored to a particular ecosystem.

When exploring open source directories, it’s essential to pay attention to project descriptions, documentation, and community engagement.

Look for projects that have an active community, clear contribution guidelines, and responsive maintainers. This ensures that you’ll have the support and guidance needed to make meaningful contributions.

Remember, open source directories are constantly evolving, with new projects and updates being added regularly.

It’s a good practice to revisit these directories periodically, keeping an eye out for exciting new projects and opportunities to contribute.

Engage in Community Discussions

Engaging in community discussions is an excellent way to identify projects in need of contributions and connect with fellow developers. Participate in forums, mailing lists, and chat rooms related to your preferred programming language or framework.

Pay attention to discussions about open issues, feature requests, or projects seeking contributors. You might stumble upon a project that matches your interests and where your skills can be put to good use.

Hackathons and Code Challenges

Participating in hackathons or code challenges not only hones your skills but also exposes you to potential open source projects.

During these events, you might encounter projects looking for contributors or even get the opportunity to collaborate with other developers on open source initiatives.

Keep an eye out for hackathons and coding competitions in your local community or online platforms like Devpost and Kaggle.

Follow Influencers and Blogs

In the developer community, influencers, and industry experts often share their insights and highlight interesting open source projects.

Follow influential developers on social media platforms like Twitter, LinkedIn, and Medium. Subscribe to developer-focused blogs and newsletters that cover open source contributions.

This way, you’ll stay up to date with the latest trends and find out about new projects seeking contributors.

Contribute to Projects You Use

Consider contributing to open source projects that you already use or benefit from in your own work.

If you come across a bug or missing feature in a tool or library you rely on, take the opportunity to fix it or implement the feature yourself.

Contributing to projects you’re familiar with not only provides practical value to your workflow but also enhances your understanding of the project’s codebase.

Attend Meetups and Conferences:

Networking at developer meetups and conferences can lead you to exciting open source projects. Engage in conversations with fellow attendees, speakers, and organizers.

Share your interest in contributing to open source, and you might receive recommendations or invitations to collaborate on existing projects or upcoming initiatives.

Conclusion

Contributing to open source projects is a fulfilling and rewarding experience that helps you grow as a developer.

By leveraging open source directories, you can easily discover a wide range of projects, from small utility libraries to large-scale frameworks.

Don’t hesitate to explore different categories, experiment with new technologies, and contribute to projects that align with your interests and career aspirations.

Remember, finding the right project takes time and patience. Don’t be afraid to explore different projects, experiment, and collaborate with others.

Happy exploring and contributing to the vibrant world of open source!

If you know anyone looking for a dev shop and need an MVP built, please intro them to me over LinkedIn — thank you for the referrals!

You can also find me on Github!

If you are a user of ChatGPT, the online chatbot powered by OpenAI’s GPT-3 model, you might have had some interesting, funny, or insightful exchanges with the bot that you want to share with others.

But how do you do that? Taking screenshots is tedious and cumbersome, and copying and pasting text is not very appealing. Fortunately, there is a better way: shared links.

Shared links are a new feature that allows you to generate a unique URL for any of your ChatGPT conversations, which you can then share with your friends, colleagues, and collaborators.

With shared links, you can let others see — and continue — your ChatGPT conversations in a simple and convenient way.

In this blog post, I will show you how to create and use shared links, as well as answer some frequently asked questions about this feature.

How to create a shared link

To create a shared link, you need to have an account on chat.openai.com, the website where you can access ChatGPT. Shared links are currently available only on the website, not on the iOS app.

To create a shared link for a conversation, follow these steps:

1. Hover over the chat that you want to share and click on the shared link icon (a chain link symbol) on the right side of the chat box.

2. You will see a preview of the conversation snapshot that you are about to share. You can scroll up and down to see the whole conversation.

3. You have the option to share your name or anonymously by clicking on the three dots on the top right corner of the preview window. If you share your name, it will appear at the top of the conversation on the shared link page. If you share anonymously, your name will not be shown.

4. When you are ready, click on the green button that says “Copy Link” to copy the URL of your shared link to your clipboard. You can then paste it anywhere you want to share it.

How to use a shared link

When someone clicks on your shared link, they will be taken to a page where they can see your conversation with ChatGPT. They can also continue the conversation by typing in their own messages and getting responses from ChatGPT.

If they have an account on chat.openai.com, they can also import the conversation into their chat history by clicking on the “Import” button on the top right corner of the page. This will allow them to save the conversation and access it later from their account.

If they don’t have an account on chat.openai.com, they can still view and continue the conversation, but they won’t be able to import it or save it.

FAQs about shared links

Here are some common questions and answers about shared links:

Are shared links public? Who can access my shared links?

§ Anyone who has access to a shared link can view and continue the linked conversation. We encourage you not to share any sensitive content, as anyone with the link can access the conversation or share it with other people.

§ If you’ve created a link that you no longer want to be public, you can delete the link or clear the conversation. The conversation will no longer be accessible via the shared link, but if a user imported the conversation into their chat history, deleting your link will not remove the conversation from their chat history.

What information about me is included in the shared link I generate?

§ By default, shared links will not include your name or any other personal information. You can choose to add your name when creating the link by clicking on the ellipsis in the shared link window, then clicking “Share your name.” If you add your name, it will appear on the page of your shared link at the top of the conversation.

§ Shared links will also not include any information about which ChatGPT model or settings you used for your conversation. The linked conversation will use the default model and settings for anyone who views or continues it.

How do I update or delete a shared link after it is created?

§ You can update or delete a shared link by opening up the link share modal for that conversation (by hovering over the chat and clicking on the shared link icon) and clicking on the three dots on the top right corner of the preview window.

§ You can update your name visibility (share your name or make it anonymous) by clicking on the corresponding option. To save your changes, you need to click on the green button that says “Update and Copy Link”.

§ You can delete a shared link by clicking on “Delete Link”. This will remove the link from your account and make it inaccessible for anyone who tries to open it.

Where can I find all my shared links?

§ You can find all your shared links in a history panel accessible via the settings modal (by clicking on your profile picture on chat.openai.com). The history panel shows all your links along with their creation dates and names (if any). You can also delete all your links at once by clicking on “Delete All Links.”

Conclusion

Shared links are a great way to share your ChatGPT conversations with others in an easy and fun way. They allow you to showcase your creativity, humor, or insights with ChatGPT without having to resort to screenshots or plain text. They also let others join in and continue your conversations with ChatGPT.

If you haven’t tried ChatGPT yet, I encourage you to sign up for an account on chat.openai.com and start chatting with one of the most advanced AI models in the world. And if you have tried ChatGPT already, I hope you enjoy using shared links and sharing your conversations with others.

Happy chatting!

If you know anyone looking for a dev shop and need an MVP built, please intro them to me over LinkedIn — thank you for the referrals!

Vector databases, also known as vectorized databases or vector similarity databases, are a type of database that are designed to store and manipulate vector data efficiently.

Vector data refers to data that can be represented as vectors, which are mathematical representations of objects or data points in multi-dimensional space.

Vector databases are particularly well-suited for handling high-dimensional data, such as embeddings or feature vectors, which are commonly used in machine learning and natural language processing tasks.

Vector databases store vectors as data points and provide specialized indexing and querying capabilities for vector-based similarity search.

They are optimized for performing vector operations, such as vector similarity computation and nearest neighbor search, which are common tasks in machine learning and recommendation systems.

Vector databases enable efficient storage and retrieval of large-scale vector data, making them ideal for applications that require fast and accurate similarity search, such as image retrieval, text search, and recommendation systems.

Examples of vector databases include:

1. Faiss: An open-source vector similarity search library developed by Facebook. Faiss provides fast and memory-efficient indexing and querying for large-scale vector data and supports various similarity metrics, such as cosine similarity and Euclidean distance.
2. Milvus: An open-source vector database that provides vector indexing and searching capabilities. Milvus supports various indexing algorithms, such as IVF (Inverted File with Vocabulary Tree) and HNSW (Hierarchical Navigable Small World), and is designed for handling large-scale vector data.
3. Annoy: An open-source C++ library for approximate nearest neighbor search, which can be used as a vector database. Annoy provides fast and memory-efficient indexing and querying for vector data and supports various distance metrics, such as Euclidean distance and cosine similarity.
4. Redis: Redis Vector databases offer a number of benefits over other vector databases. For example, Redis vector databases provide real-time search performance, built-in fault tolerance, and resilience to ensure your search applications never experience downtime. An additional benefit of a Redis vector database is the reduction of architectural and application complexity.

Now, let’s compare vector databases with NoSQL and relational databases:

1. Data Representation: Vector databases are specifically designed to store and manipulate vector data efficiently, whereas NoSQL and relational databases are generally designed for storing more traditional data types, such as text, numbers, and multimedia. Vector databases provide specialized indexing and querying capabilities for vector-based similarity search, which is not available in NoSQL or relational databases.
2. Performance: Vector databases are optimized for vector operations, such as vector similarity computation and nearest neighbor search, and can provide fast and efficient performance. NoSQL and relational databases may not be optimized for vector operations and may not perform well in tasks involving vector similarity search.
3. Scalability: Vector databases are designed to handle large-scale vector data efficiently, making them suitable for big data applications. NoSQL and relational databases may also be able to handle large-scale data, but they may not be as optimized for vector data and vector operations as vector databases.
4. Flexibility: NoSQL and relational databases provide more flexibility in terms of data modeling and schema design, allowing for dynamic and evolving data structures. Vector databases, on the other hand, may have more constraints in terms of data modeling and may require a fixed schema for vector data.
5. Querying Capabilities: Vector databases provide specialized indexing and querying capabilities for vector-based similarity search, which is a key feature for many machine learning and recommendation system applications. NoSQL and relational databases may not provide built-in support for vector similarity search or may require additional customization to achieve similar capabilities.

In summary, vector databases are specialized databases optimized for efficiently storing and querying vector data and are well-suited for applications requiring fast and accurate vector similarity search.

NoSQL and relational databases, on the other hand, are more general-purpose databases that may not be optimized for vector operations but provide more flexibility in terms of data modeling and schema design.

The choice between vector databases, NoSQL, and relational databases depends on the specific requirements of the application and the nature of the data being stored and queried.

If you know anyone looking for a dev shop and need an MVP built, please intro them to me over LinkedIn — thank you for the referrals!

API-first development approach enables developers to build flexible, scalable, and easily maintainable applications. This blog will explore the concept of API-first development, including its benefits, how to build APIs, and popular frameworks used to build APIs.

Benefits of API-First Development

API-first development offers several benefits for developers. Firstly, it promotes a modular and scalable architecture that allows developers to add or remove functionalities without affecting the entire application.

Secondly, it enables developers to build applications that are device-agnostic, meaning that the same API can be used across multiple platforms, such as desktops, mobile devices, and IoT devices.

Thirdly, API-first development encourages collaboration between developers and stakeholders, making it easier to iterate on the application during development.

Building APIs

The first step in API-first development is to create the API. APIs are typically created using a RESTful architecture, which involves creating a set of endpoints that clients can use to communicate with the server.

REST (Representational State Transfer) is an architectural style that is commonly used in web development to build web services and APIs.

RESTful architecture is an approach to building web services that follow the principles of REST. RESTful APIs are designed around resources, which are identified by URLs.

Clients can interact with these resources by making HTTP requests to their corresponding URLs. RESTful APIs use HTTP methods such as GET, POST, PUT, and DELETE to perform CRUD (create, read, update, delete) operations on resources.

A RESTful API should also follow the following constraints, as outlined by Roy Fielding in his dissertation, “Architectural Styles and the Design of Networkbased Software Architectures”:

1. Client-server architecture: The client and server should be independent of each other and should be able to evolve independently.
2. Statelessness: The server should not store any client context between requests. Each request should contain all the necessary information to perform the request.
3. Cacheability: The server should indicate whether a response can be cached or not. This reduces the number of requests made to the server and improves performance.
4. Layered system: A client should not be able to tell whether it communicates directly with the server or an intermediary.
5. Uniform interface: The interface between the client and server should be standardized to allow for independence between the two.

Following these constraints can help ensure your RESTful API is easy to use, maintain, and scale.

Endpoints are essentially URLs that are used to retrieve or manipulate data on the server. Here is an example of an endpoint in a RESTful API:

GET /api/books

This endpoint would return a list of books stored on the server. Similarly, a POST endpoint could be used to add new books to the server:

POST /api/books

When a client sends a POST request to this endpoint, it would add the book to the server's database.

Here is an example of how to create an endpoint in Node.js using the Express framework:

This code creates two endpoints using the GET and POST methods, respectively: /api/books and /api/books

Popular Frameworks for Building APIs

There are several popular frameworks that developers can use to build APIs. Here are some examples:

1. Express.js — is a popular Node.js framework for building web applications and APIs. It provides a simple and flexible routing system that makes it easy to create endpoints.
2. Django REST Framework — Django is a Python web framework with a RESTful API called Django REST Framework. It provides a wide range of features, including serialization, authentication, and pagination.
3. Ruby on Rails — Ruby on Rails is a popular web framework that includes a built-in API framework called Active Model Serializers. It allows developers to easily create and serialize JSON data for use in their APIs.

What is Authentication, and Why is it necessary?

Authentication and securing your API endpoints are critical aspects of API-first development.

Without proper authentication and security measures, your API may be vulnerable to attacks, compromising sensitive data and significantly damaging your application and reputation.

Authentication is the process of verifying the identity of a user or system. It ensures that only authorized users can access the API endpoints.

There are several authentication methods that you can use to secure your API. Here are some of the most common methods:

1. Token-based Authentication — Token-based authentication involves issuing a token to the client after they have provided their credentials.
2. The client then includes the token in every subsequent request to the API. The server validates the token to ensure that the request is authorized.
3. OAuth 2.0 — OAuth 2.0 is a widely-used authentication protocol that allows users to grant third-party applications access to their resources. It involves a series of redirects and exchanges between the client, server, and user.
4. Basic Authentication — Basic authentication involves sending the username and password in plain text with each request. This method is not recommended as it is vulnerable to interception and replay attacks.

Here is an example of how to implement token-based authentication in Node.js using the jsonwebtoken library:

This code includes two endpoints: /login and /api/books. The /login endpoint is responsible for issuing a token to the client after they have provided their credentials.

The /api/books endpoint checks if the token is valid before returning the list of books from the server's database.

Securing Your API Endpoints Securing your API endpoints involves protecting them from unauthorized access and attacks. Here are some best practices for securing your API endpoints:

1. Use HTTPS — HTTPS encrypts the data sent between the client and server, protecting it from interception and tampering.
2. Implement Rate Limiting — Rate limiting limits the number of requests a client can make to the API within a specified period. This helps to prevent denial-of-service attacks.
3. Validate Input — Validate all input received from clients to prevent injection attacks.
4. Use Role-Based Access Control — Role-based access control allows you to grant access to API endpoints based on the user’s role.

Here is an example of how to implement rate limiting in Node.js using the express-rate-limit library:

This code implements rate limiting for the /api/books endpoint, allowing a maximum of 100 requests per IP address within a 15-minute window.

Conclusion

API-first development is a powerful approach to building modern applications that are scalable and flexible.

By designing your application around your API, you can ensure it is easy to maintain and adapt to changing requirements. However, ensuring that your API is secure and follows best practices for authentication and endpoint security is important.

With popular frameworks like Express.js, Django REST Framework, and Ruby on Rails, developers have access to powerful tools to create robust and flexible APIs.

If you enjoyed reading this article, you may also enjoy reading;

Debugging Nightmare? Avoid It by Testing Your Code with Jest!

I also wrote another blog about My Experience and Learnings from Building an Exercise Tracker with Express and MongoDB.

I hope this article was useful and informative. Happy coding!

If you know anyone looking for a dev shop and need an MVP built, please intro them to me over LinkedIn — thank you for the referrals!

As someone who is passionate about software development, I ventured out to FreeCodeCamp to attempt their Backend Development and APIs Certification.

One of the projects which I was challenged to build for the certification was to create a simple exercise tracker application to keep track of exercise workouts. After researching various technologies and frameworks, I chose to use Express.js and MongoDB for my project.

During the development of this project, I learned a lot about web development, databases, and testing. I’ll share some of my experiences and learnings in this blog post.

First, I learned how to use Express.js to create a RESTful API. I started by setting up my server and routing endpoints for creating new users and adding exercises to their accounts. I used middleware functions to handle incoming requests and extract data from the request body or query parameters.

Next, I learned how to use MongoDB to store data. I created a schema for my User and Exercise models and used Mongoose to connect to my database and perform CRUD operations.

I learned how to query my database using the Mongoose API and how to use aggregation pipelines to perform more complex queries.

One of the biggest challenges I faced was writing tests for my application. I learned how to use Jest to write unit and integration tests for my server endpoints and database models.

I wrote a blog post about setting up different test scenarios for your project using Jest here; Debugging Nightmare? Avoid It by Testing Your Code with Jest!

I also learned how to use Supertest to simulate HTTP requests and test my endpoints. Testing helped me identify and fix bugs in my application and gave me confidence that my code was working as expected.

Another important skill I developed was error handling. I learned how to handle errors at various levels of my application, from input validation to database queries. I also learned how to use status codes and error messages to communicate with clients and help them debug issues.

Finally, I learned how to deploy my application to a production environment. I used Render to host my application and learned how to configure environment variables, set up a database, and deploy my code using Git.

In conclusion, building an exercise tracker with Express and MongoDB was a great learning experience. I gained valuable skills in web development, databases, testing, and deployment.

I also learned how to break down a complex project into smaller, manageable pieces and how to research and troubleshoot issues. I’m excited to continue learning and building more applications in the future.

If you know anyone looking for a dev shop and need an MVP built, please intro them to me over LinkedIn — thank you for the referrals!