DEV Community: Kaarthik Andavar

BrandVibe

Kaarthik Andavar — Mon, 26 May 2025 06:19:19 +0000

This is a submission for the Bright Data AI Web Access Hackathon

What I Built

I built a Brand Intelligence Dashboard that gives businesses real-time insights into how their brand is perceived across social media and news platforms. The system analyzes mentions from Twitter, LinkedIn, Reddit, and news sources to provide sentiment analysis, ethical context evaluation, and trending topic identification.

The frontend is a Next.js application that provides an intuitive interface where users can input any brand name, location, and category to get comprehensive analytics. The dashboard displays sentiment breakdowns, platform-specific insights, word clouds of trending themes, and ethical highlights that might impact brand reputation.

Agent Architecture

Demo

Repository:
Backend - https://github.com/kaarthik108/Know-your-Brand
Frontend - https://github.com/kaarthik108/kyb

Live Demo: https://kyb-nine.vercel.app/

The application works in two main phases:

Analysis Request: Users enter brand details or select from predefined options (Tesla, Apple, Microsoft)
AI-Agent: Agent starts doing its work to find mentions across platforms using MCP server (Brightdata)

Key features include:

Multi-platform sentiment analysis with visual breakdowns
Ethical context identification for CSR-related themes
Interactive word clouds showing trending topics
Platform-specific mention tracking with engagement metrics
Real-time polling interface during data collection

Tools:

Google ADK (Agent) with Bright Data MCP.
O4-mini to extract structured response
Deployed backend on Google Cloud Run
NExtJS frontend on Vercel

How I Used Bright Data's Infrastructure

The core of this system relies on Bright Data's MCP server to power four specialized AI agents that work in parallel:

Discovery & Access: The agents use Bright Data's infrastructure to discover and access content across Twitter, LinkedIn, Reddit, and news websites. This includes navigating complex authentication systems and dynamic content loading that would be impossible with traditional scraping.

Data Extraction: Each platform agent extracts structured data including post content, timestamps, engagement metrics, and author information. Bright Data's reliable extraction capabilities ensure we get consistent, clean data even from JavaScript-heavy social media platforms.

Real-time Interaction: The agents interact with dynamic web pages, handling infinite scroll feeds, loading more content, and navigating platform-specific UI elements to gather comprehensive mention data.

The MCP server integration allows our backend to coordinate these four agents simultaneously, dramatically reducing the time needed to gather comprehensive brand intelligence from multiple sources.

Performance Improvements

Using Bright Data's real-time web access created significant improvements over traditional approaches:

Speed: Instead of sequential API calls or unreliable scraping, our parallel agent architecture powered by Bright Data completes comprehensive brand analysis in 2-5 minutes across all four platforms.

Reliability: Traditional web scraping often fails due to anti-bot measures, rate limiting, or dynamic content. Bright Data's infrastructure handles these challenges automatically, giving us consistent data collection success rates.

Data Quality: The MCP server ensures we capture complete context around mentions - not just the text, but engagement metrics, temporal data, and surrounding conversation threads that provide richer sentiment analysis.

Scalability: The system can analyze any brand without platform-specific API limitations or access restrictions. This makes it viable for businesses of any size to get enterprise-level brand intelligence.

Real-time Insights: Unlike static datasets or delayed API responses, Bright Data enables truly current brand monitoring, allowing businesses to respond quickly to emerging trends or reputation issues.

The combination of AI agents with Bright Data's web access infrastructure transforms brand monitoring from a manual, time-intensive process into an automated, comprehensive intelligence system.

TryOutfit: Virtual Outfit Try-On with AI

Kaarthik Andavar — Mon, 27 May 2024 02:20:51 +0000

This is a submission for the The AWS Amplify Fullstack TypeScript Challenge

TryOutfit: Virtual Outfit Try-On with AI

I recently built an AI web application called TryOutfit that allows users to virtually try on outfits using AI. Powered by the IDM-VTON model from Replicate, TryOutfit provides an interactive experience for users to visualize how different outfits would look on them or on predefined models.

How It Works

TryOutfit offers a user-friendly interface where users can either upload their own image or choose from a selection of predefined models. Once an image is selected, the application uses the IDM-VTON AI model to generate a virtual try-on of the chosen outfit on the selected image. This enables users to see how the outfit would look on them or on the model without physically trying it on.

All the model generations are automatically deleted after 1hour from database.

Demo and Code

APP - https://www.tryoutfit.app/
Code - https://github.com/kaarthik108/tryoutfit

The application follows a serverless architecture, leveraging AWS services to handle various functionalities. User authentication is managed by Amazon Cognito, ensuring secure access to the application. User-uploaded images are stored in S3 buckets, while outfit and user data is stored in DynamoDB tables.

The AI model from Replicate is seamlessly integrated into the application to generate the virtual try-on images. To optimize performance, webhooks are used to poll the inference results instead of waiting for the model to complete the processing. Additionally, TryOutfit offers shareable links to the generated model outfits, which remain accessible for a period of 1 hour, enabling users to easily share their virtual try-on results with others.

Integrations

NEXTjs 14 (with server actions)
AWS s3 (To store image files)
AWS Dynamo DB (To serve product data and persist inference data)
AWS Cognito (API Key auth)
Replicate (AI model)
AWS Amplify (Hosting)

Connected Components and/or Feature Full

StorageImage from Amplify UI was used to display the images using path from s3.

Conclusion

Building TryOutfit using AWS Amplify and various AWS services has been a rewarding experience. Amplify simplifies the development process by providing a set of tools and services that make it easy to build scalable and feature-rich applications. The integration of AI models, such as the one from Replicate, adds an exciting dimension to the application, enabling users to virtually try on outfits from the comfort of their own devices.

Di1 - AI Driven Insights With Cloudflare

Kaarthik Andavar — Sun, 14 Apr 2024 10:35:10 +0000

This is a submission for the Cloudflare AI Challenge.

What I Built

Di1 is an AI-powered T2SQL Chatbot for Cloudflare D1. It allows users to interact with the Y Combinator dataset using natural language queries, can be customized to any data that is stored in Cloudlfare D1. Users can ask questions about the dataset, and Di1 will generate the corresponding SQL queries and produce charts and graphs, to retrieve the relevant information from the Cloudflare D1 database. The chatbot provides an intuitive and user-friendly interface for exploring the dataset without requiring knowledge of SQL syntax.

Demo

Deployed app - https://di1-iyr.pages.dev/

Generated example chat - https://di1-iyr.pages.dev/chat/NQFtTkt

My Code

The source code for Di1 is available on GitHub: https://github.com/kaarthik108/di1

Journey

Just went all out on cloudflare product offerings.
The project is built with the following stack:

Cloudflare Workers AI - Embedding model
Cloudflare Vectorize - Store vectors for RAG
Cloudflare AI Gateway - Caching LLM query and ratelimiting
Cloudflare Pages - Hosting Nextjs
Cloudflare Python Workers - For importing CSV data to D1
Cloudflare D1 - For context query with RAG, and also to store chat responses.
OpenAI - GPT4-turbo for function calling

Building Di1 was a valuable learning experience within a short timeframe.
The design process was rewarding, and the integration of multiple Cloudflare products resulted in a comprehensive solution.

Achieving high accuracy with function calling using the Workers AI model @hf/nousresearch/hermes-2-pro-mistral-7b proved challenging compared to GPT-4. As the app relies heavily on function calling capabilities, this is an area for future exploration as Cloudflare expands its model offerings.

Multiple Models and/or Triple Task Types

The app currently uses two LLM's
Workers AI - Embedding model @cf/baai/bge-large-en-v1.5
OpenAI - Chat model for function calling GPT4-Turbo

Team Submissions: https://dev.to/kaarthik108

Introducing Supa-Dash✨

Kaarthik Andavar — Wed, 10 Apr 2024 08:31:21 +0000

A High-Performance, Multi-Filter Dashboard Built with Vercel AI SDK and Supabase

We recently participated in a hackathon where we built Supa-Dash, a fast and efficient multi-filter dashboard that leverages the power of the Vercel AI SDK and Supabase. This project showcases the seamless integration of text-to-SQL visuals, delivering a smooth and interactive user experience.

Key Features

Real-time Data Visualization: Supa-Dash provides real-time, dynamic visualizations based on user-defined filters and queries.
Text-to-SQL Integration: Users can input natural language queries, which are automatically converted into SQL statements using the Vercel AI SDK, enabling effortless data exploration.
Scalable and Performant: Built on top of Next.js and Supabase, Supa-Dash ensures high performance and scalability, handling large datasets with ease.

Tech Stack

Supa-Dash is built using the following cutting-edge technologies:

Next.js: A powerful React framework for building server-side rendered and statically generated web applications.
Supabase: An open-source Firebase alternative that provides a fast and secure PostgreSQL database with real-time capabilities.
Vercel AI SDK: A comprehensive toolkit for integrating AI capabilities into web applications, enabling natural language processing and text-to-SQL conversion.
Tremor: React components to build charts and dashboards.
Drizzle ORM: A modern and intuitive ORM (Object-Relational Mapping) library for TypeScript and JavaScript, simplifying database interactions.
Shadcn UI: A beautifully designed component library that offers a wide range of pre-built UI components, enabling rapid development of visually appealing interfaces.

Live Demo
Check out the live demo of Supa-Dash: Supa-Dash

AWS Bedrock on Snowflake (Talk to Claude, LLAMA)

Kaarthik Andavar — Wed, 18 Oct 2023 20:19:34 +0000

Directly Linking AWS Bedrock and Snowflake Without the Hassle

Yes it is that simple to connect to AWS Bedrock directly from Snowflake without the need for snowflake external function or API Gateway.

When AI Sneaks into Data Warehousing: Expect the Unexpected

Overview of AWS Bedrock

Amazon Bedrock is a fully managed service that offers a choice of high-performing foundation models (FMs) from leading AI companies like AI21 Labs, Anthropic, Cohere, Meta, Stability AI, and Amazon with a single API, along with a broad set of capabilities you need to build generative AI applications, simplifying development while maintaining privacy and security.
Amazon Bedrock is serverless, you don't have to manage any infrastructure

What are the services required to run the project ?

AWS Lambda
Snowflake External Access Integration
Snowflake Stored Procedure

Note: This process can be simplified further without the need of AWS Lambda by just using snowflake stored procedure if the anaconda snowflake channel has their boto3 package upgraded to the latest version (boto3>=1.28.57)

How does the whole process look like ?

Integration Steps

1. Setting up Snowflake Secrets

First we create two snowflake secrets to call aws services AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY.



CREATE OR REPLACE SECRET AWS_ACCESS_KEY_ID
    TYPE = GENERIC_STRING
    SECRET_STRING = '....';

CREATE OR REPLACE SECRET AWS_SECRET_ACCESS_KEY
    TYPE = GENERIC_STRING
    SECRET_STRING = '......';

2. Configuring Snowflake Network Rules

Now create snowflake network rule, to tell snowflake to allow egress on specific traffic.



CREATE OR REPLACE NETWORK RULE AWS_EGRESS_RULE
    MODE = EGRESS
    TYPE = HOST_PORT
    VALUE_LIST = (
        'lambda.us-east-1.amazonaws.com'
    );

3. Setting Up External Access Integration in Snowflake



CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION bedrock_client
    ALLOWED_NETWORK_RULES = (AWS_EGRESS_RULE)
    ALLOWED_AUTHENTICATION_SECRETS = (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
    ENABLED = TRUE;
4. Creating the Stored Procedure
This procedure will call AWS Lambda.
CREATE OR REPLACE 
  PROCEDURE snow_claude(question STRING)
RETURNS STRING
LANGUAGE PYTHON
RUNTIME_VERSION=3.9
EXTERNAL_ACCESS_INTEGRATIONS = (bedrock_client)
SECRETS = ('AWS_ACCESS_KEY_ID' = AWS_ACCESS_KEY_ID, 'AWS_SECRET_ACCESS_KEY' = AWS_SECRET_ACCESS_KEY)
PACKAGES=('snowflake-snowpark-python', 'boto3', 'botocore', 'requests')
HANDLER='handler'
AS
$$
import json

import _snowflake
import boto3
from snowflake.snowpark import Session

# Your AWS credentials
AWS_ACCESS_KEY_ID = _snowflake.get_generic_secret_string("AWS_ACCESS_KEY_ID")
AWS_SECRET_ACCESS_KEY = _snowflake.get_generic_secret_string("AWS_SECRET_ACCESS_KEY")

#Lambda function name
FUNCTION_NAME = "snowbedrock"

# Initialize the boto3 client for Lambda
session = boto3.session.Session(region_name="us-east-1")
lambda_client = session.client(
    "lambda",
    aws_access_key_id=AWS_ACCESS_KEY_ID,
    aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
)

def invoke_lambda_function(payload):
    response = lambda_client.invoke(
        FunctionName=FUNCTION_NAME,
        InvocationType="RequestResponse",
        Payload=json.dumps(payload),
    )
    # Since the Lambda response is already parsed into a string
    return response["Payload"].read().decode("utf-8")

def handler(session: Session, question: str):
    body = {"question": question}
    try:
        response = invoke_lambda_function(body)
        parsed_response = json.loads(response)
        return parsed_response
    except Exception as err:
        print("An error occurred:", err)
        raise

$$
;

5. Lambda Function Setup

Note: The boto3 package is not upto date in AWS Lambda, make sure to zip the latest version package (boto3>=1.28.57) as a layer, the older version doesn't know about bedrock.



#snowbedrock

import json
import boto3
import os

def claude(prompt):
    bedrock_runtime = boto3.client(
        service_name="bedrock-runtime",
        region_name="us-east-1",
    )
    TEMPLATE = f'Human: "{prompt}"\nAssistant: '

    body = json.dumps(
        {
            "prompt": TEMPLATE,
            "max_tokens_to_sample": 256,
            "stop_sequences": [],
            "temperature": 0,
            "top_p": 0.9,
        }
    )
    modelId = "anthropic.claude-instant-v1"
    accept = "application/json"
    contentType = "application/json"
    response = bedrock_runtime.invoke_model(
        body=body, modelId=modelId, accept=accept, contentType=contentType
    )
    response_body = json.loads(response.get("body").read())
    print("Model Response:", response_body)

    return response_body

def lambda_handler(event, context) -> str:    
    question = event.get("question")
    if not question:
        return "No question provided"

    answer = claude(question)
    return answer["completion"]

Make sure the lambda has permission to trigger bedrock
{ "Version": "2012–10–17", "Statement": [ { "Effect": "Allow", "Action": "bedrock:*", "Resource": "*" } ] }

6. Time to test



call snow_claude('who is this elon musk?');

Elon Musk is a South African-born American entrepreneur and businessman. Some key things to know about him: - He is the founder, CEO, and Chief Engineer of SpaceX…..

I hope this guide simplifies your AWS Bedrock and Snowflake integration process.
Follow for more insightful content and to explore the world of open-source with me!
Medium: Kaarthikandavar
X: Kaarthikcodes
LinkedIn: Kaarthik

Thanks for Reading! Just another day in the tech soap opera.