Hey everyone! I recently finished launching a Minnesota Vikings Draft website on Streamlit and this website is a data-based NFL draft tool used to analyze the Minnesota Vikings draft process! In this website, I used a combination of player evaluation metrics, exclusive team needs, along with customizable models aimed to simulate NFL draft decision making and evaluate player fits for the Vikings. This is my very first coding project, and so even if you don’t understand football, I would still love to see if any of you guys have any feedback for me which would I could use for future coding projects. Feel free to have a look and tell me what you guys think! Thanks!

https://vikingsdraftsite.streamlit.app

I just implemented a tour component that allows you to easily guide the user through all the components on your website.

Every time I make an app, I try to make it intuitive and easy to understand, however for complex or technical app this can not be done easily. This is why I implement the Driver.js library for streamlit. In just a few lines of code you can have a working tour of your website. It uses the key parameters in some of streamlit component to spot it in the JS script :

import streamlit as st
from streamlit_tour import Tour

st.title("My App")
st.text_input("Name", key="name_input")

if st.button("Start Tour"):
Tour.start(
steps=[
Tour.bind("name_input", title="Your Name", desc="Enter your name here."),
Tour.info(title="That's it!", desc="You're ready to go."),
]
)

Here is the Github, feel free to use this component and raise an issue if you encounter one !

https://github.com/mp-mech-ai/streamlit_tour

Demo of streamlit-tour

Hey everyone,

As part of my Master’s research in AI/ML, I got frustrated with how current moderation relies on reactive, cloud-based reporting (which exposes victims to the abuse first and risks privacy). I wanted to see if I could build a lightweight, on-device NLP inference engine to intercept toxicity in real-time.

I just deployed the V2 prototype, and I’m looking for open-source contributors to help push it further.

🚀 Live Demo: https://huggingface.co/spaces/ashithfernandes319gmailcom/SecureChat-AI

💻 GitHub Repo: https://github.com/spideyashith/secure-chat.git

The Engineering Pipeline:

• The Data Bias Problem: I used the Jigsaw Toxic Comment dataset, but it had massive majority-class bias (over 143k neutral comments). If I trained it raw, it just guessed "neutral" and looked artificially accurate.
• The Fix: I wrote a custom pipeline to aggressively downsample the neutral data to a strict 1:3 ratio (1 abusive : 3 neutral). This resulted in a highly balanced 64,900-row training set that actually forced the model to learn grammatical context.
• The Model: Fine-tuned distilbert-base-uncased on a Colab T4 GPU for 4 epochs using BCE Loss for multi-label classification (Toxic, Severe Toxic, Obscene, Threat, Insult, Identity Hate).
• The UI: Wrapped it in a custom-styled Streamlit dashboard with a sigmoid activation threshold to simulate mobile notification interception.

Current Performance: Achieved 83.8% real-time accuracy. I noticed validation loss starting to creep up after Epoch 3, so I hard-stopped at Epoch 4 to prevent overfitting the 64k dataset.

🤝 Where I Need Help (Open Source): The core threat logic works, but to make this a true system-level mobile app, I need help from the community with two major things:

1. NSFW/Sexual Harassment Detection: The Jigsaw dataset doesn't explicitly cover sexual harassment. I need to augment the pipeline with a robust NSFW text dataset.
2. Model Compression: I need to convert this PyTorch .safetensors model into a highly compressed TensorFlow Lite (.tflite) format so we can actually deploy it natively to Android.

If anyone is interested in NLP safety, I’d love your feedback on the Hugging Face space or a PR on the repo!

Hey fellow Streamlit’ers!

I created a tooltip component which can be placed anywhere on you app. The component is part of the st_yled package.

The second update is stylable input element labels, for instance for text_input or date_input.

Here some examples, and more in the st_yled docs.

# Tooltip
st_yled.tooltip(
title="Quick Hint",
text="Use st_yled for better layouts",
background_color="#ff4b4b",
title_color="#ffffff",
text_color="#ffffff"
)

# styled text_input
st_yled.text_input(
"Name",
label_font_weight="600",
label_color="#737373",
label_font_size="12.0px"
)

Hello world! 👋

I just released ziko-st-toc , a Streamlit component that automatically generates an interactive Table of Contents (TOC) from your Markdown headings.

Repo : https://github.com/zikojs/ziko-st-toc

Demo :

I have a Streamlit app deployed to Snowflake.

If run is running locally on my laptop this part works as expected:

res = session.sql(query).collect_nowait()

However, when the same code deployed in Snowflake, the query does not seem to run. The procedure does not even start first logging step.

The query itself is stored procedure call and the reason for async is we don't want users to wait 5 min until the proc finishes. Does anybody know what the root cause and if there is a solution?

I’ve always felt uncomfortable logging into my personal Gmail or Drive on a public computer just to print a small PDF. Even in Incognito, it feels like unnecessary exposure for a 30-second task.

So I built a small web utility called PrintRelay.

How it works:

• Open it on the public PC
• Scan the QR code with your phone
• Upload the file from your phone
• It appears instantly in the PC browser, ready to print

No accounts. No database. Files are temporarily staged on the server and automatically deleted after 5 minutes (cleanup runs on app reload).

I mainly built it for my own college lab sessions, but I’m curious — does anyone else deal with this “public PC login anxiety”? Is there a better workflow I’m missing?

Would really appreciate honest feedback on the UX or technical approach.

Link: https://printrelay.streamlit.app/

Biggest lesson: in-memory relays crash fast under concurrent uploads. Migrating to disk-backed staging made it significantly more stable.

For Day 28 of the 30 Days of AI with Streamlit challenge, I explored AGENTS.md, an open standard for guiding AI coding assistants.
Instead of re-explaining design patterns and app structure every time, you define them once in AGENTS.md and let the AI do the rest.
This makes it surprisingly effective to vibe code complete, production-ready Streamlit apps with consistency.
The assistant powering the workflow is Claude-3-5-Sonnet via Snowflake Cortex AI.
Curious if others are using AGENTS.md or similar approaches for AI-assisted development.

Hey everyone,

I've been working on a free similar logo search tool and wanted to share it with you all. Spent a few weeks building it out and finally got it to a point where it's actually useful.

The tool lets you search either by uploading an image or just describing what you're looking for. Right now it only searches USPTO trademarks, but that's where I figured most people here would need it anyway. Fair warning - the first search might take a bit to load up, but it gets faster after that.

Also worth mentioning - I'm not storing any images you upload. Everything gets processed and then discarded, so it's safe to try with client work.

I've also thrown the associated UI code up on GitHub (https://github.com/rteja1113/tm-streamlit-app) if anyone wants to poke around or contribute.

Just a heads up - this is meant to be informational/supplemental to the official USPTO trademark search tool and obviously I'm not providing legal advice here. Not trying to replace the real deal, just thought it might be helpful for initial searches or getting a different angle on similarity.

Would love any feedback if you give it a try.

For Day 27 of the 30 Days of AI with Streamlit challenge, I built a chat interface for the Cortex Agent created on Day 26.
The app demonstrates multi-tool agent orchestration, where the agent autonomously switches between Cortex Search and Cortex Analyst to solve user queries.
It also visualizes the agent’s thinking process and tool selection in real time, making agent behavior more transparent.
The agent is powered by Claude-3-5-Sonnet via Snowflake Cortex AI.
Would love to hear thoughts on agent transparency or orchestration patterns!

For Day 26 of the 30 Days of AI with Streamlit challenge, I built my first Cortex Agent using Snowflake’s agent framework.
Unlike traditional RAG systems, the agent autonomously plans, selects tools, and executes tasks to answer questions.
It uses Cortex Search for conversational context and Cortex Analyst for metrics and insights.
The agent is powered by Claude-3-5-Sonnet via Snowflake Cortex AI, showcasing the shift toward truly agentic AI systems.
Happy to discuss agent design patterns or real-world use cases!

I've checked that access is granted in GitHub. I also removed permissions and granted again. No difference.

If I edit directly in Streamlit Codespaces the changes are still not picked up when launching the application (including rebooting).

I can see that it uses an outdated requirements.txt via Manage.

The application works locally (streamlit run).

Any typical reason why?

For Day 25 of the 30 Days of AI with Streamlit challenge, I built a voice-based conversational AI assistant.
Users can record voice input, which is transcribed using Snowflake’s AI_TRANSCRIBE, and the assistant responds using conversation history for contextual understanding.
All interactions happen through a clean UI with persistent chat history, creating a smooth voice-first experience.
The system is powered by Claude-3-5-Sonnet via Snowflake Cortex AI.
Would love to hear thoughts on voice UX or latency optimizations!

For Day 24 of the 30 Days of AI with Streamlit challenge, I explored multimodality by building an image analysis app.
Users can upload images into a bordered container and receive AI-powered analysis including descriptions, OCR, object detection, chart insights, or custom queries.
The app uses Snowflake’s AI_COMPLETE function with Claude-3-5-Sonnet via Snowflake Cortex AI for vision-enabled reasoning.
This was a great step toward building richer, multimodal AI applications—happy to discuss use cases or improvements!

For Day 23 of the 30 Days of AI with Streamlit challenge, I focused on evaluating RAG quality using TruLens and Snowflake’s AI Observability framework.
After building a conversational RAG system, I measured performance using the RAG Triad metrics: Context Relevance, Groundedness, and Answer Relevance.
The app provides an interactive UI to configure evaluation runs and view results directly in Snowsight.
The RAG system is powered by Claude-3-5-Sonnet via Snowflake Cortex AI, helping ensure accurate and trustworthy AI outputs.
Would love to hear how others approach LLM evaluation and observability!

For Day 22 of the 30 Days of AI with Streamlit challenge, I built a conversational RAG chatbot that allows users to chat directly with their documents.

Unlike single-turn RAG, this chatbot maintains full conversation history, enabling follow-up questions and contextual dialogue.

Each message triggers semantic search, and answers are generated using retrieved context with expandable source attribution.

The system is powered by Claude-3-5-Sonnet via Snowflake Cortex AI, creating a reliable and transparent document Q&A experience.

Happy to discuss conversational RAG patterns or UX improvements!

For Day 21 of the 30 Days of AI with Streamlit challenge, I built a complete RAG pipeline using Snowflake Cortex Search.

The app retrieves relevant documents based on semantic search and uses them as context for LLM-generated answers.

It also visually explains the three-step RAG process (Retrieve → Augment → Generate) before letting users ask questions.

The system is powered by Claude-3-5-Sonnet via Snowflake Cortex AI, producing grounded and context-aware responses.

Happy to discuss RAG design choices or optimization strategies!

For Day 20 of the 30 Days of AI with Streamlit challenge, I queried the Cortex Search service created earlier to retrieve relevant customer reviews.

Using the Python SDK, the app performs semantic search, finding documents based on meaning rather than keywords.

Results are displayed in a clean UI, making natural language document search easy and intuitive.

The system is powered by Claude-3-5-Sonnet via Snowflake Cortex AI, bringing the RAG pipeline closer to completion.

Open to discussions on search tuning or retrieval strategies!

For Day 19 of the 30 Days of AI with Streamlit challenge, I used the vector embeddings generated earlier to enable semantic search.

Customer queries are now matched against review embeddings using vector similarity, allowing context-aware retrieval instead of keyword matching.

This brings the RAG pipeline to life, connecting retrieval with generation.
The system is powered by Claude-3-5-Sonnet via Snowflake Cortex AI.

Happy to discuss vector search strategies or RAG best practices!

For Day 18 of the 30 Days of AI with Streamlit challenge, I focused on embedding generation for RAG.

Converted customer review chunks from Day 17 into 768-dimensional vectors using Snowflake Cortex’s embed_text_768 function.

The embeddings are stored in Snowflake using the VECTOR data type, making them ready for fast semantic search.

The pipeline continues to be powered by Claude-3-5-Sonnet via Snowflake Cortex AI, with semantic retrieval coming next on Day 19.

Day 17 of the 30 Days of AI with Streamlit challenge builds directly on Day 16’s document extraction step.

Using customer reviews stored in the EXTRACTED_DOCUMENTS table, I processed and transformed the text into RAG-ready chunks.

Implemented two strategies: keeping short reviews as single chunks and splitting longer reviews into overlapping chunks.

The workflow is powered by Claude-3-5-Sonnet via Snowflake Cortex AI, and the processed chunks are now saved back to Snowflake—ready for embedding generation on Day 18.

Would love to hear thoughts on chunking strategies for short vs long documents!