streamlit

17. Streamlit It makes it easy to turn Python code into interactive web apps. You can use it to quickly build things like AI chatbots, data dashboards, image tools, RAG apps, machine learning demos. streamlit/streamlit

Reduce API surface for BLAKE2 to match OpenSSL semantics This is an updated version of the original post which reduces the scope of the work on BLAKE2. I originally wanted to remove non-standard parameters to BLAKE2 to make the module more maintainable in the future as well as SIMD support, but I am planning to only remove SIMD support for now. I still think it's wrong to use tree-hashing with BLAKE2 since BLAKE3 exists and should be used instead. Nonetheless, after looking at the deprecation PRs (gh-160374 and gh-160375) and the long period this would require to actually remove the code, I don't think it's really worth it. It would at least reduce the impact to downstream users almost to zero. Instead, I suggest that we soft-deprecate the interface for tree hashing in the docs and suggest BLAKE3 instead. ---- Original post: I want to reduce BLAKE2 in hashlib to a minimal API matching OpenSSL. More precisely, BLAKE2 is kept without SIMD and matches the API of OpenSSL's BLAKE2 (digest, MAC): data and digest_size for the hash, and salt/person with a key. Tree hashing, salt/person without a key, and HMAC-BLAKE2 will be deprecated in 3.16 and removed in 3.21. If necessary, the deprecation period will be extended to a few more releases but I really want to get rid of the annoying API surface. BLAKE2 is already a keyed hash function, it doesn't make sense to use HMAC on top of it, despite some libraries using the HMAC-BLAKE2 HACL* sources for that (see gh-138114). In an ideal world, I would remove BLAKE2 and recommend BLAKE3 or SHA-based alternatives. Note that currently (and likely in the future), there are no plans to add BLAKE3 to hashlib (see gh-83479). For a fast secure hash, BLAKE3 is available as the blake3 package. It is maintained by the BLAKE3 authors, has a hashlib-like API, supports keyed hashing and key derivation, and has wheels for all major platforms. Maintenance pain BLAKE2 has been in hashlib since 3.6, first as a custom module with our own implementation, then as a wrapper around the vendored HACL* sources (support for HACL* HMAC was added in 3.14, together with support for BLAKE2 despite numerous shortcomings on some platforms). BLAKE2 has the largest API in hashlib (key, salt, person and seven tree-hashing parameters). Most of its maintenance cost comes from the SIMD code: it needs per-platform compiler flags and CPU detection as well as dedicated code paths for the vectorized versions, is only enabled on (some) x86-64, and usually breaks on non-Tier-1 platforms: - gh-123748: macOS universal2 builds failed (SIMD256 compiles for x86-64 but not ARM64); - gh-124304: SIMD had to be disabled on older Android versions; - gh-126458: SIMD support wrongly detected under WASI; - gh-128134: missing aligned_alloc check on older macOS; - gh-130213: older toolchains failed without the SIMD flags; - gh-133042: duplicate symbols when cross-compiling for Emscripten (still unfixed); - gh-138114: HMAC-BLAKE2 does not properly use the SIMD implementations (still unfixed). The module also needed several correctness fixes (gh-152851, gh-155830, gh-155835). Impact GitHub code search (excluding forks, CPython copies and vendored site-packages) finds about 34,000 Python files using hashlib.blake2b, 4,800 using hashlib.blake2s, and 300 using hashlib.new("blake2b") or hashlib.new("blake2s"). 62 of the 500 most-starred active Python repositories on GitHub use BLAKE2, e.g. PyTorch, Transformers, Home Assistant, Sentry, Streamlit, Gradio and Airflow. Of 1,753 sampled call sites (1,420 repositories), 1,649 (1,336 repositories) only use digest_size, 59 (51 repositories) use key, and 45 (38 repositories) use salt or person without a key. None use tree hashing. Most of them only need a fast hash, for which SHA-2, SHA-3 or BLAKE3 also work. This includes: - projects that store digests, such as Home Assistant (cache filenames), Mathesar (database identifiers) and Onyx (search-index IDs); - projects that depend on the exact BLAKE2 output, such as networkx (graph hashes), LangChain (indexing), apprise and a minisign verifier (BLAKE2b-512 signatures), copyparty (client checksums); - projects that use keyed BLAKE2 such as agno (MinHash) and openai-python (Bedrock helper); or - projects such as PyPI or Poetry for checksums, Warehouse for storage and publishing (though it looks like a legacy API), or python-tuf. One popular project affected by this change would be ComfyUI (which uses person without a key). In particular, I don't expect too much of downstream breakage (considering the long deprecation period) but I would appreciate if anyone against this proposal could explain why SIMD BLAKE2 should be kept (note that I already plan to remove SIMD support in 3.16 without a deprecation notice as it created too many issues, while exposing the OpenSSL implementation). Note that projects can rely on nacl.hash.blake2b (PyNaCl does not offer a 2s version) or PyCryptodome for blake2b and blake2s. AFAIK, there is no PyPI packages providing the tree-hashing feature but the latter is neither standardized by an RFC nor used in the wild. ---- > AI disclosure: Opus 5.5 was used for collecting and classifying data.

Python 脚本写好了，还缺一个展示页面？🐍 Streamlit 几行代码就能加图表和交互。做数据看板或 AI Demo，直接在浏览器展示。📊 streamlit/streamlit #Python #WebApp #浇朋友 #蓝朋友 #互关 #fo

Build a Streamlit App Together with Git-Backed Workspaces in Snowflake In this video, Chanin Nantasenamat, PhD (aka @DataProfessor) shows you how to build a Streamlit app with a teammate while each of you uses your own preferred tools. This walkthrough follows one developer working in Snowsight and another working from the terminal, with GitHub keeping their changes on the same branch. You'll see how to connect Snowflake to GitHub using a secret and API integration, fork the sample repository, and create a shared Git branch. Then we'll create a Git-backed workspace in Snowsight, convert the app for Workspaces, preview it, and commit the first edit. Next, we'll pull those changes locally, add another example prompt, push it back to GitHub, and pull it into the browser workspace. Finally, we'll deploy the app and compare this Git-based workflow with shared workspaces. Along the way, we'll distinguish private previews from deployment and show the explicit push-and-pull steps that move changes between tools. 📚 Resources - Code streamlit/simple-streamlit-app - Snowflake Git Workspaces Docs docs.snowflake.com - Streamlit Docs docs.streamlit.io ⏳ Timestamps 0:00 One app, two developer workflows 1:12 Connect Snowflake to GitHub 2:28 Fork the sample repo and check connectivity 3:20 Clone the repo and push a shared branch 4:28 Create a Git-backed workspace in Snowsight 5:29 Convert, preview, edit, and push the app 7:06 Pull changes and add a prompt from the terminal 7:59 Pull the update into Snowsight 8:28 Deploy the Streamlit app 9:13 Recap: Git-backed and shared workspaces #streamlit #snowflake [ar] بناء تطبيق Streamlit بشكل تعاوني باستخدام مساحات العمل المدعومة بـ Git في Snowflake في هذا الفيديو، يُقدّم لكم الدكتور شانين نانتاسينامات (المعروف أيضًا باسم @DataProfessor) شرحًا لكيفية بناء تطبيق Streamlit مع زميل، حيث يستخدم كل منكما أدواته المفضلة. يتبع هذا الشرح العملي مطورًا يعمل على Snowflake وآخر يعمل من سطر الأوامر، مع احتفاظ GitHub بتغييراتهما على نفس الفرع. ستتعرفون على كيفية ربط Snowflake بـ GitHub باستخدام كلمة مرور سرية وتكامل واجهة برمجة التطبيقات (API)، وكيفية إنشاء نسخة من مستودع العينة، وإنشاء فرع Git مشترك. بعد ذلك، سننشئ مساحة عمل مدعومة بـ Git في Snowflake، ونُحوّل التطبيق ليتوافق مع Workspaces، ونُعاينه، ونُثبّت أول تعديل. ثم، سنسحب هذه التغييرات محليًا، ونُضيف مثالًا آخر للمُوجّه، ونُعيد رفعه إلى GitHub، ونسحبه إلى مساحة عمل المتصفح. أخيرًا، سننشر التطبيق ونُقارن سير العمل القائم على Git هذا مع مساحات العمل المشتركة. خلال الشرح، سنُميّز بين المعاينات الخاصة والنشر، ونُوضّح خطوات الدفع والسحب التي تنقل التغييرات بين الأدوات. 📚 الموارد - الكود: streamlit/simple-streamlit-app - وثائق Snowflake Git Workspaces: docs.snowflake.com - وثائق Streamlit: docs.streamlit.io ⏳ الفهرس الزمني 0:00 تطبيق واحد، مساران عمل للمطورين 1:12 ربط Snowflake بـ GitHub 2:28 إنشاء نسخة من مستودع العينة والتحقق من الاتصال 3:20 استنساخ المستودع ودفع فرع مشترك 4:28 إنشاء مساحة عمل مدعومة بـ Git في Snowsight 5:29 تحويل التطبيق ومعاينته وتعديله ودفعه 7:06 سحب التغييرات وإضافة موجه من الطرفية 7:59 سحب التحديث إلى Snowsight 8:28 نشر تطبيق Streamlit 9:13 ملخص: Git المدعوم والمشترك مساحات عمل #إضاءة_مستمرة #ندفة_ثلج [bn] স্নোফ্লেকে গিট-ব্যাকড ওয়ার্কস্পেসের মাধ্যমে একসাথে স্ট্রিমলিট অ্যাপ তৈরি করুন এই ভিডিওতে, ডঃ চানিন নানতাসেনামাত (ওরফে @DataProfessor) আপনাকে দেখাবেন কীভাবে একজন টিমমেটের সাথে একটি স্ট্রিমলিট অ্যাপ তৈরি করতে হয়, যেখানে আপনারা প্রত্যেকে নিজেদের পছন্দের টুল ব্যবহার করবেন। এই ওয়াকথ্রু-তে দেখানো হয়েছে কীভাবে একজন ডেভেলপার স্নোসাইট (Snowsight) এবং অন্যজন টার্মিনাল থেকে কাজ করছেন, এবং গিটহাব (GitHub) তাদের পরিবর্তনগুলো একই ব্রাঞ্চে রাখছে। আপনি দেখবেন কীভাবে একটি সিক্রেট এবং এপিআই ইন্টিগ্রেশন ব্যবহার করে স্নোফ্লেককে (Snowflake) গিটহাবের সাথে সংযুক্ত করতে হয়, স্যাম্পল রিপোজিটরিটি ফর্ক করতে হয় এবং একটি শেয়ার্ড গিট ব্রাঞ্চ তৈরি করতে হয়। এরপর আমরা স্নোসাইটে একটি গিট-ব্যাকড ওয়ার্কস্পেস তৈরি করব, অ্যাপটিকে ওয়ার্কস্পেসের জন্য রূপান্তর করব, সেটির প্রিভিউ দেখব এবং প্রথম এডিটটি কমিট করব। এরপর, আমরা সেই পরিবর্তনগুলো লোকালি পুল (pull) করব, আরেকটি উদাহরণ প্রম্পট যোগ করব, সেটিকে আবার গিটহাবে পুশ (push) করব এবং ব্রাউজার ওয়ার্কস্পেসে পুল করব। সবশেষে, আমরা অ্যাপটি ডিপ্লয় (deploy) করব এবং এই গিট-ভিত্তিক ওয়ার্কফ্লো-কে শেয়ার্ড ওয়ার্কস্পেসের সাথে তুলনা করব। এই পুরো প্রক্রিয়ার মধ্যে, আমরা প্রাইভেট প্রিভিউ এবং ডিপ্লয়মেন্টের মধ্যে পার্থক্য তুলে ধরব এবং টুলগুলোর মধ্যে পরিবর্তন স্থানান্তরের জন্য সুস্পষ্ট পুশ ও পুল ধাপগুলো দেখাব। 📚 রিসোর্স - কোড streamlit/simple-streamlit-app - Snowflake Git Workspaces Docs docs.snowflake.com - Streamlit Docs docs.streamlit.io ⏳ টাইমস্ট্যাম্প ০:০০ একটি অ্যাপ, দুটি ডেভেলপার ওয়ার্কফ্লো ১:১২ Snowflake-কে GitHub-এর সাথে সংযুক্ত করুন ২:২৮ স্যাম্পল রিপোটি ফর্ক করুন এবং কানেক্টিভিটি পরীক্ষা করুন ৩:২০ রিপোটি ক্লোন করুন এবং একটি শেয়ার্ড ব্রাঞ্চ পুশ করুন ৪:২৮ Snowsight-এ একটি Git-ব্যাকড ওয়ার্কস্পেস তৈরি করুন ৫:২৯ অ্যাপটি কনভার্ট, প্রিভিউ, এডিট এবং পুশ করুন ৭:০৬ পরিবর্তনগুলো পুল করুন এবং টার্মিনাল থেকে একটি প্রম্পট যোগ করুন ৭:৫৯ Snowsight-এ আপডেটটি পুল করুন ৮:২৮ Streamlit অ্যাপটি ডিপ্লয় করুন ৯:১৩ সারসংক্ষেপ: Git-ব্যাকড এবং শেয়ার্ড ওয়ার্কস্পেস #streamlit #তুষারকণা [de-DE] Gemeinsame Entwicklung einer Streamlit-App mit Git-gestützten Arbeitsbereichen in Snowflake In diesem Video zeigt Ihnen Dr. Chanin Nantasenamat (alias @DataProfessor), wie Sie gemeinsam mit einem Teammitglied eine Streamlit-App entwickeln, wobei jeder seine bevorzugten Tools verwendet. Die Anleitung folgt einem Entwickler, der in Snowsight arbeitet, und einem anderen, der im Terminal arbeitet. GitHub speichert die Änderungen im selben Branch. Sie erfahren, wie Sie Snowflake mithilfe eines Secrets und einer API-Integration mit GitHub verbinden, das Beispiel-Repository forken und einen gemeinsamen Git-Branch erstellen. Anschließend erstellen wir einen Git-basierten Workspace in Snowsight, konvertieren die App für Workspaces, zeigen eine Vorschau an und committen die erste Änderung. Als Nächstes laden wir diese Änderungen lokal herunter, fügen eine weitere Beispiel-Prompt hinzu, laden sie zurück nach GitHub und laden sie in den Browser-Workspace. Abschließend stellen wir die App bereit und vergleichen diesen Git-basierten Workflow mit gemeinsam genutzten Workspaces. Dabei unterscheiden wir zwischen privaten Vorschauen und der Bereitstellung und zeigen die einzelnen Push- und Pull-Schritte, die Änderungen zwischen den Tools übertragen. 📚 Ressourcen - Code: streamlit/simple-streamlit-app - Snowflake Git Workspaces-Dokumentation: docs.snowflake.com - Streamlit-Dokumentation: docs.streamlit.io ⏳ Zeitstempel 0:00 Eine App, zwei Entwickler-Workflows 1:12 Snowflake mit GitHub verbinden 2:28 Beispiel-Repository forken und Verbindung prüfen 3:20 Repository klonen und einen gemeinsamen Branch pushen 4:28 Git-basierten Workspace in Snowsight erstellen 5:29 App konvertieren, Vorschau anzeigen, bearbeiten und pushen 7:06 Änderungen abrufen und eine Eingabeaufforderung über das Terminal hinzufügen 7:59 Aktualisierung in Snowsight abrufen 8:28 Streamlit-App bereitstellen 9:13 Zusammenfassung: Git-basierte und gemeinsame Workspaces #streamlit #snowflake [es-US] Crea una aplicación de Streamlit en equipo con espacios de trabajo respaldados por Git en Snowflake En este vídeo, Chanin Nantasenamat, PhD (también conocido como @DataProfessor), te muestra cómo crear una aplicación Streamlit con un compañero, utilizando cada uno sus propias herramientas. Este tutorial sigue a un desarrollador trabajando en Snowsight y a otro desde la terminal, con GitHub manteniendo sus cambios en la misma rama. Verás cómo conectar Snowflake con GitHub mediante una clave secreta y la integración de la API, cómo bifurcar el repositorio de ejemplo y cómo crear una rama Git compartida. A continuación, crearemos un espacio de trabajo con Git en Snowsight, convertiremos la aplicación para Workspaces, la previsualizaremos y confirmaremos la primera edición. Luego, descargaremos esos cambios localmente, añadiremos otro mensaje de ejemplo, lo subiremos de nuevo a GitHub y lo descargaremos al espacio de trabajo del navegador. Finalmente, implementaremos la aplicación y compararemos este flujo de trabajo basado en Git con los espacios de trabajo compartidos. Durante el proceso, distinguiremos las previsualizaciones privadas de la implementación y mostraremos los pasos explícitos de subir y descargar cambios entre herramientas. 📚 Recursos - Código: streamlit/simple-streamlit-app - Documentación de Espacios de Trabajo Git de Snowflake: docs.snowflake.com - Documentación de Streamlit: docs.streamlit.io ⏳ Marcas de tiempo 0:00 Una app, dos flujos de trabajo para desarrolladores 1:12 Conectar Snowflake con GitHub 2:28 Bifurcar el repositorio de ejemplo y comprobar la conectividad 3:20 Clonar el repositorio y enviar una rama compartida 4:28 Crear un espacio de trabajo con Git en Snowsight 5:29 Convertir, previsualizar, editar y enviar la app 7:06 Descargar los cambios y añadir una solicitud desde la terminal 7:59 Descargar la actualización en Snowsight 8:28 Implementar la app Streamlit 9:13 Resumen: Espacios de trabajo compartidos y con Git #streamlit #copo de nieve [fr-FR] Créez ensemble une application Streamlit avec les espaces de travail Git dans Snowflake Dans cette vidéo, Chanin Nantasenamat, PhD (alias @DataProfessor), vous montre comment créer une application Streamlit en collaboration avec un collègue, chacun utilisant ses outils préférés. Ce tutoriel suit un développeur travaillant dans Snowflake et un autre depuis le terminal, GitHub conservant leurs modifications sur la même branche. Vous découvrirez comment connecter Snowflake à GitHub à l'aide d'un secret et d'une intégration API, dupliquer le dépôt d'exemple et créer une branche Git partagée. Nous créerons ensuite un espace de travail Git dans Snowflake, convertirons l'application pour Workspaces, la prévisualiserons et validerons la première modification. Puis, nous récupérerons ces modifications localement, ajouterons une autre invite de commande d'exemple, la renverrons sur GitHub et l'intégrerons à l'espace de travail du navigateur. Enfin, nous déploierons l'application et comparerons ce flux de travail basé sur Git avec les espaces de travail partagés. Nous distinguerons les prévisualisations privées du déploiement et détaillerons les étapes de push et de pull permettant de transférer les modifications entre les outils. 📚 Ressources - Code : streamlit/simple-streamlit-app - Documentation Snowflake Git Workspaces : docs.snowflake.com - Documentation Streamlit : docs.streamlit.io ⏳ Horodatage 0:00 Une application, deux flux de travail de développement 1:12 Connecter Snowflake à GitHub 2:28 Forker le dépôt d'exemple et vérifier la connectivité 3:20 Cloner le dépôt et envoyer une branche partagée 4:28 Créer un espace de travail Git dans Snowsight 5:29 Convertir, prévisualiser, modifier et envoyer l'application 7:06 Récupérer les modifications et ajouter une invite depuis le terminal 7:59 Intégrer la mise à jour dans Snowsight 8:28 Déployer l'application Streamlit 9:13 Récapitulatif : Espaces de travail Git et partagés #streamlit #snowflake [hi] Snowflake में Git-बैक्ड वर्कस्पेस के साथ मिलकर Streamlit ऐप बनाएं इस वीडियो में, डॉ. चानिन नंतासेनामत (उर्फ़ @DataProfessor) आपको अपने साथी के साथ Streamlit ऐप बनाना सिखाती हैं, जिसमें आप दोनों अपने पसंदीदा टूल का इस्तेमाल करते हैं। इस वीडियो में एक डेवलपर Snowsight में और दूसरा टर्मिनल से काम करते हुए दिखाया गया है, जिसमें GitHub उनके बदलावों को एक ही ब्रांच पर रखता है। आप देखेंगे कि सीक्रेट और API इंटीग्रेशन का इस्तेमाल करके Snowflake को GitHub से कैसे कनेक्ट किया जाता है, सैंपल रिपॉजिटरी को कैसे फोर्क किया जाता है और एक साझा Git ब्रांच कैसे बनाई जाती है। फिर हम Snowsight में एक Git-आधारित वर्कस्पेस बनाएंगे, ऐप को वर्कस्पेस के लिए कन्वर्ट करेंगे, उसका प्रीव्यू देखेंगे और पहला एडिट कमिट करेंगे। इसके बाद, हम उन बदलावों को लोकल रूप से पुल करेंगे, एक और उदाहरण प्रॉम्प्ट जोड़ेंगे, उसे GitHub पर पुश करेंगे और उसे ब्राउज़र वर्कस्पेस में पुल करेंगे। आखिर में, हम ऐप को डिप्लॉय करेंगे और इस Git-आधारित वर्कफ़्लो की तुलना साझा वर्कस्पेस से करेंगे। इस दौरान, हम प्राइवेट प्रीव्यू और डिप्लॉयमेंट के बीच का अंतर समझाएंगे और टूल के बीच बदलावों को ट्रांसफर करने वाले स्पष्ट पुश और पुल स्टेप्स दिखाएंगे। 📚 संसाधन - कोड streamlit/simple-streamlit-app - स्नोफ्लेक गिट वर्कस्पेस दस्तावेज़ docs.snowflake.com - स्ट्रीमलिट दस्तावेज़ docs.streamlit.io ⏳ समय-सीमाएँ 0:00 एक ऐप, दो डेवलपर वर्कफ़्लो 1:12 स्नोफ्लेक को गिटहब से कनेक्ट करें 2:28 सैंपल रेपो को फ़ॉर्क करें और कनेक्टिविटी की जाँच करें 3:20 रेपो को क्लोन करें और एक साझा शाखा पुश करें 4:28 स्नोसाइट में गिट-आधारित वर्कस्पेस बनाएँ 5:29 ऐप को कन्वर्ट करें, प्रीव्यू करें, एडिट करें और पुश करें 7:06 टर्मिनल से बदलाव पुल करें और प्रॉम्प्ट जोड़ें 7:59 स्नोसाइट में अपडेट पुल करें 8:28 स्ट्रीमलिट ऐप डिप्लॉय करें 9:13 सारांश: गिट-आधारित और साझा वर्कस्पेस #streamlit # हिमखंड [id] Membangun Aplikasi Streamlit Bersama dengan Git-Backed Workspaces di Snowflake Dalam video ini, Chanin Nantasenamat, PhD (alias @DataProfessor) menunjukkan cara membangun aplikasi Streamlit bersama rekan tim, sementara masing-masing menggunakan alat pilihan sendiri. Panduan ini mengikuti satu pengembang yang bekerja di Snowsight dan pengembang lain yang bekerja dari terminal, dengan GitHub menyimpan perubahan mereka di cabang yang sama. Anda akan melihat cara menghubungkan Snowflake ke GitHub menggunakan rahasia dan integrasi API, melakukan fork repositori sampel, dan membuat cabang Git bersama. Kemudian kita akan membuat ruang kerja berbasis Git di Snowsight, mengkonversi aplikasi untuk Ruang Kerja, melihat pratinjaunya, dan melakukan commit perubahan pertama. Selanjutnya, kita akan menarik perubahan tersebut secara lokal, menambahkan contoh prompt lain, mendorongnya kembali ke GitHub, dan menariknya ke ruang kerja browser. Terakhir, kita akan menyebarkan aplikasi dan membandingkan alur kerja berbasis Git ini dengan ruang kerja bersama. Sepanjang proses, kita akan membedakan pratinjau pribadi dari penyebaran dan menunjukkan langkah-langkah push dan pull eksplisit yang memindahkan perubahan antar alat. 📚 Sumber Daya - Kode streamlit/simple-streamlit-app - Dokumentasi Ruang Kerja Git Snowflake docs.snowflake.com - Dokumentasi Streamlit docs.streamlit.io ⏳ Cap Waktu 0:00 Satu aplikasi, dua alur kerja pengembang 1:12 Hubungkan Snowflake ke GitHub 2:28 Fork repositori sampel dan periksa konektivitas 3:20 Kloning repositori dan dorong cabang bersama 4:28 Buat ruang kerja berbasis Git di Snowsight 5:29 Konversi, pratinjau, edit, dan dorong aplikasi 7:06 Tarik perubahan dan tambahkan prompt dari terminal 7:59 Tarik pembaruan ke Snowsight 8:28 Sebarkan aplikasi Streamlit 9:13 Rekap: Ruang kerja berbasis Git dan ruang kerja bersama #streamlit #snowflake [it] Sviluppa un'app Streamlit insieme ad altri con le aree di lavoro basate su Git in Snowflake In questo video, Chanin Nantasenamat, PhD (alias @DataProfessor) vi mostra come creare un'app Streamlit con un collega, ognuno utilizzando i propri strumenti preferiti. Questa guida illustra come uno sviluppatore lavora in Snowsight e un altro dal terminale, con GitHub che mantiene le modifiche sullo stesso ramo. Vedrete come connettere Snowflake a GitHub tramite un segreto e l'integrazione API, come creare un fork del repository di esempio e come creare un ramo Git condiviso. Successivamente, creeremo un'area di lavoro basata su Git in Snowsight, convertiremo l'app per Workspaces, la visualizzeremo in anteprima e applicheremo la prima modifica. In seguito, scaricheremo le modifiche localmente, aggiungeremo un altro prompt di esempio, lo caricheremo nuovamente su GitHub e lo caricheremo nell'area di lavoro del browser. Infine, distribuiremo l'app e confronteremo questo flusso di lavoro basato su Git con le aree di lavoro condivise. Lungo il percorso, distingueremo le anteprime private dalla distribuzione e mostreremo i passaggi espliciti di push e pull per spostare le modifiche tra i diversi strumenti. 📚 Risorse - Codice sorgente: streamlit/simple-streamlit-app - Documentazione sugli spazi di lavoro Git di Snowflake: docs.snowflake.com - Documentazione di Streamlit: docs.streamlit.io ⏳ Indice dei contenuti 0:00 Un'app, due flussi di lavoro per sviluppatori 1:12 Connettere Snowflake a GitHub 2:28 Effettuare il fork del repository di esempio e verificare la connettività 3:20 Clonare il repository e caricare un ramo condiviso 4:28 Creare uno spazio di lavoro con supporto Git in Snowsight 5:29 Convertire, visualizzare in anteprima, modificare e caricare l'app 7:06 Scaricare le modifiche e aggiungere un prompt dal terminale 7:59 Scaricare l'aggiornamento in Snowsight 8:28 Distribuire l'app Streamlit 9:13 Riepilogo: Spazi di lavoro con supporto Git e condivisi #streamlit #snowflake [iw] בניית אפליקציית Streamlit במשותף עם סביבות עבודה מבוססות Git ב-Snowflake בסרטון זה, Chanin Nantasenamat, PhD (aka @DataProfessor) מראה לכם כיצד לבנות אפליקציית Streamlit עם חבר צוות, כאשר כל אחד מכם משתמש בכלים המועדפים עליו. הדרכה זו עוקבת אחר מפתח אחד שעובד ב-Snowsight ואחר שעובד מהטרמינל, כאשר GitHub שומר את השינויים שלו באותו ענף. תראו כיצד לחבר את Snowflake ל-GitHub באמצעות אינטגרציה של סוד ו-API, למזג את מאגר הדוגמאות וליצור ענף Git משותף. לאחר מכן ניצור סביבת עבודה מגובה ב-Git ב-Snowsight, נמיר את האפליקציה עבור סביבות עבודה, נציג אותה בתצוגה מקדימה ונבצע את העריכה הראשונה. לאחר מכן, נמשוך את השינויים הללו באופן מקומי, נוסיף הנחיה לדוגמה נוספת, נחזיר אותה ל-GitHub ונמשוך אותה לסביבת העבודה של הדפדפן. לבסוף, נפרוס את האפליקציה ונשווה את זרימת העבודה מבוססת ה-Git הזו עם סביבות עבודה משותפות. לאורך הדרך, נבחין בין תצוגות מקדימות פרטיות לפריסה ונציג את שלבי הדחיפה-והמשיכה המפורשים שמעבירים שינויים בין כלים. 📚 משאבים - קוד streamlit/simple-streamlit-app - Snowflake Git Workspaces Docs docs.snowflake.com - Streamlit Docs docs.streamlit.io ⏳ חותמות זמן 0:00 אפליקציה אחת, שתי זרימות עבודה למפתחים 1:12 חיבור Snowflake ל-GitHub 2:28 העברת מאגר הדוגמה ובדיקת קישוריות 3:20 שכפול המאגר ודחיפת ענף משותף 4:28 יצירת סביבת עבודה מגובה Git ב-Snowsight 5:29 המרה, תצוגה מקדימה, עריכה ודחיפה של האפליקציה 7:06 משיכת שינויים והוספת בקשה מהטרמינל 7:59 משיכת העדכון ל-Snowsight 8:28 פריסת אפליקציית Streamlit 9:13 סיכום: סביבות עבודה מגובה Git ומשותפות #streamlit #snowflake [ja] SnowflakeのGit連携ワークスペースでStreamlitアプリを共同開発する方法 このビデオでは、Chanin Nantasenamat博士（別名@DataProfessor）が、チームメイトとそれぞれ好みのツールを使いながらStreamlitアプリを構築する方法を解説します。このチュートリアルでは、Snowsightで作業する開発者とターミナルで作業する開発者が、GitHubで同じブランチに変更を共有する様子を順を追って説明します。 まず、シークレットとAPI連携を使ってSnowflakeとGitHubを接続する方法、サンプルリポジトリをフォークする方法、そして共有Gitブランチを作成する方法を学びます。次に、SnowsightでGitベースのワークスペースを作成し、アプリをワークスペース用に変換し、プレビューして最初の編集をコミットします。 続いて、ローカルで変更をプルし、別のサンプルプロンプトを追加し、GitHubにプッシュして、ブラウザのワークスペースにプルします。最後に、アプリをデプロイし、このGitベースのワークフローと共有ワークスペースを比較します。その過程で、プライベートプレビューとデプロイの違いを明確にし、ツール間で変更を移動させるプッシュとプルの手順を具体的に示します。 📚 リソース - コード streamlit/simple-streamlit-app - Snowflake Git ワークスペース ドキュメント docs.snowflake.com - Streamlit ドキュメント docs.streamlit.io ⏳ タイムスタンプ 0:00 1つのアプリ、2つの開発者ワークフロー 1:12 Snowflake を GitHub に接続 2:28 サンプルリポジトリをフォークして接続を確認 3:20 リポジトリをクローンして共有ブランチをプッシュ 4:28 Snowsight で Git ベースのワークスペースを作成 5:29 アプリの変換、プレビュー、編集、プッシュ 7:06 ターミナルから変更をプルしてプロンプトを追加 7:59 Snowsight に更新をプル 8:28 Streamlit アプリをデプロイ 9:13 まとめ: Git ベースのワークスペースと共有ワークスペース #streamlit #snowflake [ko] Snowflake에서 Git 기반 워크스페이스를 사용하여 Streamlit 앱 함께 빌드하기 이 비디오에서 Chanin Nantasenamat 박사(@DataProfessor)는 각자 선호하는 도구를 사용하여 팀원과 함께 Streamlit 앱을 구축하는 방법을 보여줍니다. 이 튜토리얼에서는 한 개발자는 Snowflake에서, 다른 개발자는 터미널에서 작업하고, GitHub에서는 두 개발자의 변경 사항이 동일한 브랜치에 저장되는 방식을 따릅니다. 이 비디오에서는 시크릿과 API 통합을 사용하여 Snowflake와 GitHub를 연결하고, 샘플 저장소를 포크하고, 공유 Git 브랜치를 생성하는 방법을 보여줍니다. 그런 다음 Snowflake에서 Git 기반 워크스페이스를 생성하고, 앱을 워크스페이스용으로 변환하고, 미리 보기를 하고, 첫 번째 편집 내용을 커밋합니다. 다음으로, 이러한 변경 사항을 로컬로 가져오고, 또 다른 예제 프롬프트를 추가하고, GitHub에 푸시하고, 브라우저 워크스페이스로 가져옵니다. 마지막으로 앱을 배포하고 이 Git 기반 워크플로를 공유 워크스페이스와 비교합니다. 이 과정에서 비공개 미리 보기와 배포의 차이점을 설명하고, 도구 간에 변경 사항을 이동하는 명확한 푸시 및 풀 단계를 보여줍니다. 📚 참고 자료 - 코드: streamlit/simple-streamlit-app - Snowflake Git 워크스페이스 문서: docs.snowflake.com - Streamlit 문서: docs.streamlit.io ⏳ 타임스탬프 0:00 하나의 앱, 두 가지 개발자 워크플로 1:12 Snowflake를 GitHub에 연결 2:28 샘플 리포지토리 포크 및 연결 확인 3:20 리포지토리 클론 및 공유 브랜치 푸시 4:28 Snowsight에서 Git 기반 워크스페이스 생성 5:29 앱 변환, 미리 보기, 편집 및 푸시 7:06 변경 사항 풀 및 터미널에서 프롬프트 추가 7:59 Snowsight에 업데이트 풀 8:28 Streamlit 앱 배포 9:13 요약: Git 기반 및 공유 워크스페이스 #streamlit #snowflake [ml] Snowflake-ൽ Git-backed വർക്ക്സ്‌പെയ്‌സുകൾ ഉപയോഗിച്ച് ഒരു Streamlit ആപ്പ് ഒരുമിച്ച് നിർമ്മിക്കാം ഈ വീഡിയോയിൽ, ചാനിൻ നന്തസെനാമാറ്റ്, പിഎച്ച്ഡി (aka @DataProfessor) നിങ്ങൾ ഓരോരുത്തരും നിങ്ങളുടെ ഇഷ്ടപ്പെട്ട ഉപകരണങ്ങൾ ഉപയോഗിക്കുമ്പോൾ ഒരു സഹപ്രവർത്തകനുമായി ഒരു സ്ട്രീംലിറ്റ് ആപ്പ് എങ്ങനെ നിർമ്മിക്കാമെന്ന് കാണിച്ചുതരുന്നു. സ്നോസൈറ്റിൽ പ്രവർത്തിക്കുന്ന ഒരു ഡെവലപ്പറെയും ടെർമിനലിൽ നിന്ന് പ്രവർത്തിക്കുന്ന മറ്റൊരാളെയും ഈ വാക്ക്ത്രൂ പിന്തുടരുന്നു, GitHub അവരുടെ മാറ്റങ്ങൾ ഒരേ ബ്രാഞ്ചിൽ സൂക്ഷിക്കുന്നു. ഒരു രഹസ്യവും API സംയോജനവും ഉപയോഗിച്ച് സ്നോഫ്ലേക്കിനെ GitHub-ലേക്ക് എങ്ങനെ ബന്ധിപ്പിക്കാമെന്ന് നിങ്ങൾ കാണും, സാമ്പിൾ റിപ്പോസിറ്ററി ഫോർക്ക് ചെയ്യുകയും ഒരു പങ്കിട്ട Git ബ്രാഞ്ച് സൃഷ്ടിക്കുകയും ചെയ്യും. തുടർന്ന് ഞങ്ങൾ സ്നോസൈറ്റിൽ ഒരു Git-ബാക്ക്ഡ് വർക്ക്‌സ്‌പെയ്‌സ് സൃഷ്‌ടിക്കുകയും വർക്ക്‌സ്‌പെയ്‌സുകൾക്കായി ആപ്പ് പരിവർത്തനം ചെയ്യുകയും പ്രിവ്യൂ ചെയ്യുകയും ആദ്യ എഡിറ്റ് നടത്തുകയും ചെയ്യും. അടുത്തതായി, ഞങ്ങൾ ആ മാറ്റങ്ങൾ പ്രാദേശികമായി പിൻവലിക്കുകയും മറ്റൊരു ഉദാഹരണ പ്രോംപ്റ്റ് ചേർക്കുകയും GitHub-ലേക്ക് തിരികെ തള്ളുകയും ബ്രൗസർ വർക്ക്‌സ്‌പെയ്‌സിലേക്ക് വലിക്കുകയും ചെയ്യും. ഒടുവിൽ, ഞങ്ങൾ ആപ്പ് വിന്യസിക്കുകയും പങ്കിട്ട വർക്ക്‌സ്‌പെയ്‌സുകളുമായി ഈ Git-അധിഷ്ഠിത വർക്ക്‌ഫ്ലോ താരതമ്യം ചെയ്യുകയും ചെയ്യും. വഴിയിൽ, ഞങ്ങൾ സ്വകാര്യ പ്രിവ്യൂകളെ വിന്യാസത്തിൽ നിന്ന് വേർതിരിക്കുകയും ഉപകരണങ്ങൾക്കിടയിൽ മാറ്റങ്ങൾ നീക്കുന്ന വ്യക്തമായ പുഷ്-ആൻഡ്-പുൾ ഘട്ടങ്ങൾ കാണിക്കുകയും ചെയ്യും. 📚 ഉറവിടങ്ങൾ - കോഡ് streamlit/simple-streamlit-app - സ്നോഫ്ലേക്ക് ജിറ്റ് വർക്ക്‌സ്‌പെയ്‌സസ് ഡോക്‌സ് docs.snowflake.com - സ്ട്രീംലിറ്റ് ഡോക്‌സ് docs.streamlit.io ⏳ ടൈംസ്റ്റാമ്പുകൾ 0:00 ഒരു ആപ്പ്, രണ്ട് ഡെവലപ്പർ വർക്ക്‌ഫ്ലോകൾ 1:12 സ്നോഫ്ലേക്ക് GitHub-ലേക്ക് ബന്ധിപ്പിക്കുക 2:28 സാമ്പിൾ റെപ്പോ ഫോർക്ക് ചെയ്ത് കണക്റ്റിവിറ്റി പരിശോധിക്കുക 3:20 റെപ്പോ ക്ലോൺ ചെയ്ത് ഒരു പങ്കിട്ട ബ്രാഞ്ച് പുഷ് ചെയ്യുക 4:28 സ്നോസൈറ്റിൽ ഒരു ജിറ്റ്-ബാക്ക്ഡ് വർക്ക്‌സ്‌പെയ്‌സ് സൃഷ്ടിക്കുക 5:29 ആപ്പ് പരിവർത്തനം ചെയ്യുക, പ്രിവ്യൂ ചെയ്യുക, എഡിറ്റ് ചെയ്യുക, പുഷ് ചെയ്യുക 7:06 മാറ്റങ്ങൾ വലിച്ച് ടെർമിനലിൽ നിന്ന് ഒരു പ്രോംപ്റ്റ് ചേർക്കുക 7:59 അപ്‌ഡേറ്റ് സ്നോസൈറ്റിലേക്ക് വലിക്കുക 8:28 സ്ട്രീംലിറ്റ് ആപ്പ് വിന്യസിക്കുക 9:13 റീക്യാപ്പ്: ജിറ്റ്-ബാക്ക്ഡ്, പങ്കിട്ട വർക്ക്‌സ്‌പെയ്‌സുകൾ #streamlit #snowflake [nl-NL] Samen een Streamlit-app bouwen met Git-backed workspaces in Snowflake In deze video laat Chanin Nantasenamat, PhD (ook bekend als @DataProfessor) je zien hoe je samen met een teamgenoot een Streamlit-app bouwt, waarbij ieder zijn eigen favoriete tools gebruikt. Deze handleiding volgt een ontwikkelaar die in Snowsight werkt en een andere die vanuit de terminal werkt, waarbij GitHub hun wijzigingen op dezelfde branch bewaart. Je ziet hoe je Snowflake met GitHub verbindt met behulp van een secret en API-integratie, hoe je de voorbeeldrepository fork en hoe je een gedeelde Git-branch aanmaakt. Vervolgens maken we een Git-gebaseerde workspace in Snowsight aan, converteren we de app voor Workspaces, bekijken we een preview en committen we de eerste bewerking. Daarna halen we die wijzigingen lokaal op, voegen we een nieuwe voorbeeldprompt toe, pushen we deze terug naar GitHub en halen we deze op in de browserworkspace. Tot slot implementeren we de app en vergelijken we deze Git-gebaseerde workflow met gedeelde workspaces. Onderweg maken we onderscheid tussen privé-previews en implementatie en laten we de expliciete push- en pull-stappen zien die nodig zijn om wijzigingen tussen tools te verplaatsen. 📚 Bronnen - Code: streamlit/simple-streamlit-app - Snowflake Git Workspaces-documentatie: docs.snowflake.com - Streamlit-documentatie: docs.streamlit.io ⏳ Tijdstempels 0:00 Eén app, twee workflows voor ontwikkelaars 1:12 Snowflake verbinden met GitHub 2:28 De voorbeeldrepository forken en de connectiviteit controleren 3:20 De repository klonen en een gedeelde branch pushen 4:28 Een Git-gebaseerde workspace in Snowsight maken 5:29 De app converteren, bekijken, bewerken en pushen 7:06 Wijzigingen ophalen en een prompt toevoegen vanuit de terminal 7:59 De update in Snowsight ophalen 8:28 De Streamlit-app implementeren 9:13 Samenvatting: Git-gebaseerde en gedeelde workspaces #streamlit #sneeuwvlok [pa] Snowflake ਵਿੱਚ Git-backed workspaces ਨਾਲ ਮਿਲ ਕੇ ਇੱਕ Streamlit ਐਪ ਬਣਾਓ ਇਸ ਵੀਡੀਓ ਵਿੱਚ, ਚੈਨਿਨ ਨੈਂਟਸੇਨਾਮਤ, ਪੀਐਚਡੀ (ਉਰਫ਼ @DataProfessor) ਤੁਹਾਨੂੰ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ ਇੱਕ ਟੀਮਮੇਟ ਨਾਲ ਇੱਕ ਸਟ੍ਰੀਮਲਿਟ ਐਪ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ ਜਦੋਂ ਕਿ ਤੁਹਾਡੇ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਆਪਣੇ ਪਸੰਦੀਦਾ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ ਵਾਕਥਰੂ ਸਨੋਸਾਈਟ ਵਿੱਚ ਕੰਮ ਕਰਨ ਵਾਲੇ ਇੱਕ ਡਿਵੈਲਪਰ ਅਤੇ ਟਰਮੀਨਲ ਤੋਂ ਕੰਮ ਕਰਨ ਵਾਲੇ ਦੂਜੇ ਡਿਵੈਲਪਰ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ GitHub ਆਪਣੇ ਬਦਲਾਵਾਂ ਨੂੰ ਉਸੇ ਸ਼ਾਖਾ 'ਤੇ ਰੱਖਦਾ ਹੈ। ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ ਇੱਕ ਗੁਪਤ ਅਤੇ API ਏਕੀਕਰਣ ਦੀ ਵਰਤੋਂ ਕਰਕੇ Snowflake ਨੂੰ GitHub ਨਾਲ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ, ਨਮੂਨਾ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਫੋਰਕ ਕਰਨਾ ਹੈ, ਅਤੇ ਇੱਕ ਸਾਂਝੀ Git ਸ਼ਾਖਾ ਬਣਾਉਣਾ ਹੈ। ਫਿਰ ਅਸੀਂ ਸਨੋਸਾਈਟ ਵਿੱਚ ਇੱਕ Git-ਬੈਕਡ ਵਰਕਸਪੇਸ ਬਣਾਵਾਂਗੇ, ਵਰਕਸਪੇਸ ਲਈ ਐਪ ਨੂੰ ਬਦਲਾਂਗੇ, ਇਸਦਾ ਪੂਰਵਦਰਸ਼ਨ ਕਰਾਂਗੇ, ਅਤੇ ਪਹਿਲਾ ਸੰਪਾਦਨ ਕਰਾਂਗੇ। ਅੱਗੇ, ਅਸੀਂ ਉਹਨਾਂ ਬਦਲਾਵਾਂ ਨੂੰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਖਿੱਚਾਂਗੇ, ਇੱਕ ਹੋਰ ਉਦਾਹਰਣ ਪ੍ਰੋਂਪਟ ਜੋੜਾਂਗੇ, ਇਸਨੂੰ GitHub ਵਿੱਚ ਵਾਪਸ ਧੱਕਾਂਗੇ, ਅਤੇ ਇਸਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਰਕਸਪੇਸ ਵਿੱਚ ਖਿੱਚਾਂਗੇ। ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਐਪ ਨੂੰ ਤੈਨਾਤ ਕਰਾਂਗੇ ਅਤੇ ਇਸ Git-ਅਧਾਰਿਤ ਵਰਕਫਲੋ ਦੀ ਤੁਲਨਾ ਸਾਂਝੇ ਵਰਕਸਪੇਸਾਂ ਨਾਲ ਕਰਾਂਗੇ। ਰਸਤੇ ਵਿੱਚ, ਅਸੀਂ ਨਿੱਜੀ ਪੂਰਵਦਰਸ਼ਨਾਂ ਨੂੰ ਤੈਨਾਤੀ ਤੋਂ ਵੱਖ ਕਰਾਂਗੇ ਅਤੇ ਸਪਸ਼ਟ ਪੁਸ਼-ਐਂਡ-ਪੁਲ ਕਦਮ ਦਿਖਾਵਾਂਗੇ ਜੋ ਟੂਲਸ ਦੇ ਵਿਚਕਾਰ ਬਦਲਾਅ ਨੂੰ ਹਿਲਾਉਂਦੇ ਹਨ। 📚 ਸਰੋਤ - ਕੋਡ streamlit/simple-streamlit-app - Snowflake Git Workspaces Docs docs.snowflake.com - Streamlit Docs docs.streamlit.io ⏳ ਟਾਈਮਸਟੈਂਪ 0:00 ਇੱਕ ਐਪ, ਦੋ ਡਿਵੈਲਪਰ ਵਰਕਫਲੋ 1:12 Snowflake ਨੂੰ GitHub ਨਾਲ ਕਨੈਕਟ ਕਰੋ 2:28 ਸੈਂਪਲ ਰੈਪੋ ਨੂੰ ਫੋਰਕ ਕਰੋ ਅਤੇ ਕਨੈਕਟੀਵਿਟੀ ਦੀ ਜਾਂਚ ਕਰੋ 3:20 ਰੈਪੋ ਨੂੰ ਕਲੋਨ ਕਰੋ ਅਤੇ ਇੱਕ ਸਾਂਝੀ ਸ਼ਾਖਾ ਨੂੰ ਪੁਸ਼ ਕਰੋ 4:28 Snowsight ਵਿੱਚ ਇੱਕ Git-ਬੈਕਡ ਵਰਕਸਪੇਸ ਬਣਾਓ 5:29 ਐਪ ਨੂੰ ਕਨਵਰਟ ਕਰੋ, ਪ੍ਰੀਵਿਊ ਕਰੋ, ਸੰਪਾਦਿਤ ਕਰੋ ਅਤੇ ਪੁਸ਼ ਕਰੋ 7:06 ਤਬਦੀਲੀਆਂ ਨੂੰ ਖਿੱਚੋ ਅਤੇ ਟਰਮੀਨਲ ਤੋਂ ਇੱਕ ਪ੍ਰੋਂਪਟ ਜੋੜੋ 7:59 ਅੱਪਡੇਟ ਨੂੰ Snowsight ਵਿੱਚ ਖਿੱਚੋ 8:28 Streamlit ਐਪ ਨੂੰ ਤੈਨਾਤ ਕਰੋ 9:13 ਰੀਕੈਪ: Git-ਬੈਕਡ ਅਤੇ ਸਾਂਝੀਆਂ ਵਰਕਸਪੇਸਾਂ #streamlit #snowflake [pl] Współpraca przy tworzeniu aplikacji Streamlit z wykorzystaniem obszarów roboczych Git w Snowflake W tym filmie dr Chanin Nantasenamat (znany również jako @DataProfessor) pokazuje, jak zbudować aplikację Streamlit z członkiem zespołu, korzystając z własnych, preferowanych narzędzi. W tym instruktażu jeden programista pracuje w Snowsight, a drugi w terminalu, a GitHub przechowuje ich zmiany w tej samej gałęzi. Zobaczysz, jak połączyć Snowflake z GitHubem za pomocą klucza tajnego i integracji API, wykonać fork przykładowego repozytorium i utworzyć współdzieloną gałąź Git. Następnie utworzymy w Snowsight obszar roboczy z obsługą Git, przekonwertujemy aplikację na obszary robocze, wyświetlimy jej podgląd i zatwierdzimy pierwszą edycję. Następnie wczytamy te zmiany lokalnie, dodamy kolejny przykładowy monit, prześlemy go z powrotem do GitHub i wciągniemy do obszaru roboczego przeglądarki. Na koniec wdrożymy aplikację i porównamy ten przepływ pracy oparty na Git ze współdzielonymi obszarami roboczymi. Po drodze odróżnimy prywatne podglądy od wdrożeń i pokażemy szczegółowe kroki push-and-pull, które przenoszą zmiany między narzędziami. 📚 Zasoby - Kod streamlit/simple-streamlit-app - Dokumentacja Snowflake Git Workspaces docs.snowflake.com - Dokumentacja Streamlit docs.streamlit.io ⏳ Znaczniki czasu 0:00 Jedna aplikacja, dwa przepływy pracy dla programistów 1:12 Połącz Snowflake z GitHubem 2:28 Rozwidl przykładowe repozytorium i sprawdź łączność 3:20 Sklonuj repozytorium i prześlij współdzieloną gałąź 4:28 Utwórz obszar roboczy z wsparciem Git w Snowsight 5:29 Konwertuj, podglądaj, edytuj i prześlij aplikację 7:06 Pobieranie zmian i dodawanie monitu z terminala 7:59 Pobieranie aktualizacji do Snowsight 8:28 Wdrażanie aplikacji Streamlit 9:13 Podsumowanie: Wsparcie Git i współdzielone przestrzenie robocze #streamlit #płatek śniegu [pt-BR] Crie um aplicativo Streamlit em equipe com workspaces baseados em Git no Snowflake Neste vídeo, Chanin Nantasenamat, PhD (também conhecido como @DataProfessor) mostra como criar um aplicativo Streamlit com um colega, cada um usando suas ferramentas preferidas. Este passo a passo acompanha um desenvolvedor trabalhando no Snowflake e outro no terminal, com o GitHub mantendo as alterações na mesma branch. Você verá como conectar o Snowflake ao GitHub usando um segredo e a integração da API, criar um fork do repositório de exemplo e uma branch Git compartilhada. Em seguida, criaremos um espaço de trabalho baseado em Git no Snowflake, converteremos o aplicativo para Workspaces, visualizaremos a prévia e confirmaremos a primeira edição. Depois, baixaremos essas alterações localmente, adicionaremos outro prompt de exemplo, enviaremos as alterações de volta para o GitHub e as baixaremos para o espaço de trabalho do navegador. Finalmente, implantaremos o aplicativo e compararemos esse fluxo de trabalho baseado em Git com espaços de trabalho compartilhados. Ao longo do processo, diferenciaremos as prévias privadas da implantação e mostraremos as etapas explícitas de push e pull que transferem as alterações entre as ferramentas. 📚 Recursos - Código: streamlit/simple-streamlit-app - Documentação do Snowflake Git Workspaces: docs.snowflake.com - Documentação do Streamlit: docs.streamlit.io ⏳ Marcações de tempo 0:00 Um aplicativo, dois fluxos de trabalho para desenvolvedores 1:12 Conectar o Snowflake ao GitHub 2:28 Fazer um fork do repositório de exemplo e verificar a conectividade 3:20 Clonar o repositório e enviar uma branch compartilhada 4:28 Criar um espaço de trabalho com suporte a Git no Snowsight 5:29 Converter, visualizar, editar e enviar o aplicativo 7:06 Atualizar as alterações e adicionar um prompt do terminal 7:59 Atualizar o aplicativo Streamlit no Snowsight 8:28 Implantar o aplicativo Streamlit 9:13 Resumo: Espaços de trabalho compartilhados e com suporte a Git #streamlit #floco de neve [ru] Совместная разработка приложений Streamlit с помощью рабочих областей с поддержкой Git в Snowflake В этом видео Чанин Нантасенамат, доктор философии (он же @DataProfessor), покажет вам, как создать приложение Streamlit вместе с коллегой, используя при этом каждый из вас свои предпочтительные инструменты. В этом пошаговом руководстве один разработчик работает в Snowsight, а другой — в терминале, при этом изменения хранятся в одной и той же ветке GitHub. Вы увидите, как подключить Snowflake к GitHub с помощью секрета и интеграции API, создать форк примера репозитория и общую ветку Git. Затем мы создадим рабочее пространство с поддержкой Git в Snowsight, преобразуем приложение для рабочих пространств, проведем предварительный просмотр и зафиксируем первое изменение. Далее мы загрузим эти изменения локально, добавим еще один пример запроса, отправим его обратно в GitHub и загрузим в рабочее пространство браузера. Наконец, мы развернем приложение и сравним этот рабочий процесс на основе Git с общими рабочими пространствами. Попутно мы разграничим приватный предварительный просмотр и развертывание и покажем явные шаги push- и pull, которые перемещают изменения между инструментами. 📚 Ресурсы - Код streamlit/simple-streamlit-app - Документация по рабочим пространствам Git в Snowflake docs.snowflake.com - Документация Streamlit docs.streamlit.io ⏳ Временные метки 0:00 Одно приложение, два рабочих процесса разработчика 1:12 Подключение Snowflake к GitHub 2:28 Создание форка репозитория-примера и проверка подключения 3:20 Клонирование репозитория и отправка общей ветки 4:28 Создание рабочего пространства с поддержкой Git в Snowsight 5:29 Преобразование, предварительный просмотр, редактирование и отправка приложения 7:06 Получение изменений и добавление приглашения командной строки из терминала 7:59 Загрузка обновления в Snowsight 8:28 Развертывание приложения Streamlit 9:13 Итог: поддержка Git и общее рабочее пространство рабочие места #streamlit #snowflake [ta] Snowflake-இல் Git-ஆதரவுள்ள பணித்தளங்களைக் கொண்டு Streamlit செயலியை இணைந்து உருவாக்குவது எப்படி இந்த வீடியோவில், சானின் நந்தசெனமத், PhD (என்கிற @DataProfessor), உங்கள் இருவரில் ஒவ்வொருவரும் தங்களுக்கு விருப்பமான கருவிகளைப் பயன்படுத்திக்கொண்டு, ஒரு குழு உறுப்பினருடன் இணைந்து ஒரு ஸ்ட்ரீம்லிட் செயலியை எவ்வாறு உருவாக்குவது என்பதைக் காட்டுகிறார். இந்த செயல்முறை விளக்கத்தில், ஒரு டெவலப்பர் ஸ்னோசைட்டிலும், மற்றொருவர் டெர்மினலிலும் பணிபுரிவதைப் பின்பற்றுகிறோம்; இதில் கிட்ஹப் அவர்களின் மாற்றங்களை ஒரே கிளையில் வைத்திருக்கிறது. ஒரு சீக்ரெட் மற்றும் ஏபிஐ ஒருங்கிணைப்பைப் பயன்படுத்தி ஸ்னோஃப்ளேக்கை கிட்ஹப்புடன் இணைப்பது, மாதிரி ரெபாசிட்டரியை ஃபோர்க் செய்வது, மற்றும் ஒரு பகிரப்பட்ட கிட் கிளையை உருவாக்குவது எப்படி என்பதை நீங்கள் காண்பீர்கள். பின்னர், ஸ்னோசைட்டில் ஒரு கிட்-ஆதரவுள்ள வொர்க்ஸ்பேஸை உருவாக்கி, செயலியை வொர்க்ஸ்பேஸ்களுக்காக மாற்றி, அதை முன்னோட்டமிட்டு, முதல் திருத்தத்தை கமிட் செய்வோம். அடுத்து, அந்த மாற்றங்களை உள்ளூரில் புல் செய்து, மற்றொரு எடுத்துக்காட்டு ப்ராம்ப்டைச் சேர்த்து, அதை மீண்டும் கிட்ஹப்பிற்கு புஷ் செய்து, பிரவுசர் வொர்க்ஸ்பேஸிற்குள் புல் செய்வோம். இறுதியாக, செயலியை டிப்ளாய் செய்து, இந்த கிட் அடிப்படையிலான பணிப்பாய்வை பகிரப்பட்ட வொர்க்ஸ்பேஸ்களுடன் ஒப்பிடுவோம். இதன் வழியில், தனிப்பட்ட முன்னோட்டங்களை டிப்ளாய்மென்ட்டிலிருந்து வேறுபடுத்திக் காட்டுவோம், மேலும் கருவிகளுக்கு இடையில் மாற்றங்களை நகர்த்தும் தெளிவான புஷ் மற்றும் புல் படிகளைக் காண்பிப்போம். 📚 ஆதாரங்கள் - குறியீடு streamlit/simple-streamlit-app - Snowflake Git Workspaces ஆவணங்கள் docs.snowflake.com - Streamlit ஆவணங்கள் docs.streamlit.io ⏳ நேரக்குறிப்புகள் 0:00 ஒரு செயலி, இரண்டு டெவலப்பர் பணிப்பாய்வுகள் 1:12 Snowflake-ஐ GitHub உடன் இணைத்தல் 2:28 மாதிரி ரெப்போவை ஃபோர்க் செய்து இணைப்பைச் சரிபார்த்தல் 3:20 ரெப்போவை குளோன் செய்து ஒரு பகிரப்பட்ட கிளையை புஷ் செய்தல் 4:28 Snowsight-இல் ஒரு Git-ஆதரவு பணிவெளியை உருவாக்குதல் 5:29 செயலியை மாற்றி, முன்னோட்டமிட்டு, திருத்தி, புஷ் செய்தல் 7:06 மாற்றங்களைப் புல் செய்து, டெர்மினலில் இருந்து ஒரு ப்ராம்ப்டைச் சேர்த்தல் 7:59 புதுப்பிப்பை Snowsight-க்குள் புல் செய்தல் 8:28 Streamlit செயலியை டிப்ளாய் செய்தல் 9:13 மீள்பார்வை: Git-ஆதரவு மற்றும் பகிரப்பட்ட பணிவெளிகள் #streamlit #snowflake [te] Snowflakeలో గిట్-బ్యాక్డ్ వర్క్‌స్పేస్‌లతో స్ట్రీమ్‌లిట్ యాప్‌ను కలిసి రూపొందించండి ఈ వీడియోలో, చానిన్ నంతసేనమత్, PhD (అకా @DataProfessor) మీలో ప్రతి ఒక్కరూ తమకు నచ్చిన టూల్స్‌ను ఉపయోగిస్తూ, మీ సహోద్యోగితో కలిసి ఒక స్ట్రీమ్‌లిట్ యాప్‌ను ఎలా నిర్మించాలో మీకు చూపిస్తారు. ఈ వాక్‌త్రూలో, ఒక డెవలపర్ స్నోసైట్‌లో పనిచేస్తుండగా, మరొకరు టెర్మినల్ నుండి పనిచేస్తారు, గిట్‌హబ్ వారి మార్పులను ఒకే బ్రాంచ్‌లో ఉంచుతుంది. ఒక సీక్రెట్ మరియు API ఇంటిగ్రేషన్‌ను ఉపయోగించి స్నోఫ్లేక్‌ను గిట్‌హబ్‌కు ఎలా కనెక్ట్ చేయాలో, శాంపుల్ రిపోజిటరీని ఫోర్క్ చేయడం, మరియు ఒక షేర్డ్ గిట్ బ్రాంచ్‌ను సృష్టించడం ఎలాగో మీరు చూస్తారు. ఆ తర్వాత, మనం స్నోసైట్‌లో ఒక గిట్-ఆధారిత వర్క్‌స్పేస్‌ను సృష్టించి, యాప్‌ను వర్క్‌స్పేస్‌ల కోసం కన్వర్ట్ చేసి, దానిని ప్రివ్యూ చేసి, మొదటి ఎడిట్‌ను కమిట్ చేస్తాము. తరువాత, మనం ఆ మార్పులను లోకల్‌గా పుల్ చేసి, మరొక ఉదాహరణ ప్రాంప్ట్‌ను జోడించి, దానిని తిరిగి గిట్‌హబ్‌కు పుష్ చేసి, బ్రౌజర్ వర్క్‌స్పేస్‌లోకి పుల్ చేస్తాము. చివరగా, మనం యాప్‌ను డిప్లాయ్ చేసి, ఈ గిట్-ఆధారిత వర్క్‌ఫ్లోను షేర్డ్ వర్క్‌స్పేస్‌లతో పోలుస్తాము. ఈ క్రమంలో, మనం ప్రైవేట్ ప్రివ్యూలను డిప్లాయ్‌మెంట్ నుండి వేరు చేసి చూపిస్తాము మరియు టూల్స్ మధ్య మార్పులను తరలించే స్పష్టమైన పుష్-అండ్-పుల్ దశలను చూపిస్తాము. 📚 వనరులు - కోడ్ streamlit/simple-streamlit-app - స్నోఫ్లేక్ గిట్ వర్క్‌స్పేసెస్ డాక్యుమెంటేషన్ docs.snowflake.com - స్ట్రీమ్‌లిట్ డాక్యుమెంటేషన్ docs.streamlit.io ⏳ టైమ్‌స్టాంప్‌లు 0:00 ఒక యాప్, రెండు డెవలపర్ వర్క్‌ఫ్లోలు 1:12 స్నోఫ్లేక్‌ను గిట్‌హబ్‌కు కనెక్ట్ చేయండి 2:28 శాంపుల్ రెపోను ఫోర్క్ చేసి, కనెక్టివిటీని తనిఖీ చేయండి 3:20 రెపోను క్లోన్ చేసి, షేర్డ్ బ్రాంచ్‌ను పుష్ చేయండి 4:28 స్నోసైట్‌లో గిట్-ఆధారిత వర్క్‌స్పేస్‌ను సృష్టించండి 5:29 యాప్‌ను కన్వర్ట్, ప్రివ్యూ, ఎడిట్ మరియు పుష్ చేయండి 7:06 టెర్మినల్ నుండి మార్పులను పుల్ చేసి, ప్రాంప్ట్‌ను జోడించండి 7:59 అప్‌డేట్‌ను స్నోసైట్‌లోకి పుల్ చేయండి 8:28 స్ట్రీమ్‌లిట్ యాప్‌ను డిప్లాయ్ చేయండి 9:13 పునశ్చరణ: గిట్-ఆధారిత మరియు షేర్డ్ వర్క్‌స్పేస్‌లు #streamlit #snowflake [uk] Спільна розробка застосунку Streamlit за допомогою Git-робочих просторів у Snowflake У цьому відео Чанін Нантасенамат, доктор філософії (він же @DataProfessor), показує, як створити застосунок Streamlit разом з колегою, використовуючи власні інструменти. У цьому покроковому посібнику один розробник працює в Snowsight, а інший — з терміналу, при цьому GitHub зберігає їхні зміни в одній гілці. Ви побачите, як підключити Snowflake до GitHub за допомогою секрету та інтеграції API, створити форк репозиторію зразків та спільну гілку Git. Потім ми створимо робочий простір на базі Git у Snowsight, конвертуємо застосунок для робочих просторів, переглянемо його та зафіксуємо перше редагування. Далі ми витягнемо ці зміни локально, додамо ще один приклад запиту, відправимо його назад до GitHub та перетягнемо в робочий простір браузера. Нарешті, ми розгорнемо застосунок та порівняємо цей робочий процес на основі Git зі спільними робочими просторами. Попутно ми розрізнимо приватні попередні перегляди від розгортання та покажемо чіткі кроки вилучення та передачі змін між інструментами. 📚 Ресурси - Код streamlit/simple-streamlit-app - Документація робочих просторів Snowflake Git docs.snowflake.com - Документація Streamlit docs.streamlit.io ⏳ Мітки часу 0:00 Один додаток, два робочих процеси розробника 1:12 Підключення Snowflake до GitHub 2:28 Створення форку зразка репозиторію та перевірка підключення 3:20 Клонування репозиторію та публікація спільної гілки 4:28 Створення робочого простору на базі Git у Snowsight 5:29 Конвертація, попередній перегляд, редагування та публікація додатка 7:06 Завантаження змін та додавання запиту з терміналу 7:59 Завантаження оновлення в Snowsight 8:28 Розгортання додатка Streamlit 9:13 Підсумок: Робочі простори на базі Git та спільні робочі простори #streamlit #snowflake

GitHub 不是程序员的专利：普通人免费拿 AI 工具的完整方法 你想要的那些 AI 工具——本地大模型、自动生成短视频、语音转字幕——原版大多免费放在 GitHub 上，只是你不会找、不会判断、不敢装。这期视频不讲写代码，专讲普通人怎么把 GitHub 用起来：专家搜索法（附可复制的搜索式）、六维验货法避开停更与假项目、三种难度的安装路径、报错时怎么让 AI 帮你解决，以及一套每周九十分钟的长期追踪系统。 核心观点：GitHub 不只是代码托管，它是普通人进入 AI、开源与全球创新生态的入口。 章节： 00:00 你想要的 AI 工具，原版免费在 GitHub 01:31 Git 和 GitHub 到底有什么区别 02:46 GitHub、网盘、软件商店，谁是谁 03:34 一点八亿开发者的平台：GitHub 有多大 04:13 为什么新工具总是先出现在这里 04:55 三个普通人立刻能用的免费工具 06:53 专家搜索法：三条可复制的搜索式 10:14 避坑：归档与停更项目长什么样 10:40 六维验货法：判断一个项目靠不靠谱 11:37 许可证速查：哪些能商用，哪些碰不得 13:33 三种难度：把开源项目装上电脑 15:00 AI 帮你读项目、解报错、做改造 18:08 三条安全红线 19:01 每周九十分钟：把 GitHub 变成你的情报系统 22:06 今日实战任务 本期搜索式（可直接复制）： 1) 找今年新出的 AI 智能体：topic:ai-agent created:＞2026-01-01 stars:＞100 2) 找能一键部署的自托管工具：in:readme "docker compose" topic:self-hosted stars:＞5000 3) 识别停更项目（避坑）：stars:＞10000 pushed:＜2024-01-01 提到的项目： Ollama（本地大模型）：ollama/ollama MoneyPrinterTurbo（自动短视频）：harry0703/MoneyPrinterTurbo faster-whisper（语音转字幕）：SYSTRAN/faster-whisper yt-dlp（视频下载）：yt-dlp/yt-dlp n8n（自动化）：n8n-io/n8n Crawl4AI（网页采集）：unclecode/crawl4ai ComfyUI（AI 绘图/视频）：Comfy-Org/ComfyUI Streamlit（数据应用）：streamlit/streamlit Music: "Inspired" by Kevin MacLeod (incompetech.com) Licensed under Creative Commons: By Attribution 4.0 creativecommons.org 数据来源与核验日期见置顶评论。Star 数为 2026-10-16 核验约数，会随时间变化。 #GitHub #开源 #AI工具 #零基础教程 #人工智能

Build Your First Local AI Chat App with Ollama and Python: A Step-by-Step Guide --- title: "Build Your First Local AI Chat App with Ollama and Python: A Step-by-Step Guide" published: true description: "Understand the model, runtime, conversation state, and failure handling behind a local AI chat application." tags: ai, python, beginners, tutorial series: "AI Engineering: From Fundamentals to Production" --- An AI demo often starts with a few lines of code: send a prompt, receive an answer, display it on a screen. That is a useful beginning. But it leaves several questions unanswered. Where is the model running? Does it remember earlier messages? Why is the first response slow? What happens when the model server stops? And why can a confident answer still be wrong? In this first article, we will build a local chat application and use it to understand the components behind those questions. The goal is a small application whose behavior you can inspect and change. What you will build: a Python chat interface that sends conversation history to a local model, displays its answer, measures response time, and handles common failures. What you will learn: the difference between a model and its runtime, how chat history becomes model input, why context needs limits, and what must change before this becomes a production service. 1. The three components behind the chat window Our application has three main components: | Component | Responsibility | Our choice | | --- | --- | --- | | User interface | Accept input, display messages, keep session state | Streamlit | | Inference runtime | Load model weights and execute generation | Ollama | | Language model | Generate an answer from the supplied context | qwen3:1.7b | The model is the learned set of parameters. The runtime is the software that loads those parameters and performs inference. The application controls the conversation and decides what to send. Ollama exposes an HTTP interface on your machine. The Python application calls it; your browser displays the Python application's interface. There are two local services to keep distinct: the chat interface usually runs on port 8501, while Ollama uses port 11434. For this lab, inference runs locally using a downloaded model. Installation and model download require internet access. We do not use a paid model API. Reference repositories These are the upstream projects used in this tutorial: - Ollama on GitHub - Streamlit on GitHub You do not need to clone their source repositories. We install their tools and write a small application that uses them. 2. Prerequisites and realistic hardware expectations Use Python 3.11 or 3.12 for this tutorial, a terminal, and a code editor. The commands below cover macOS, Linux, and Windows PowerShell. We use a small model so the first example is accessible. The Ollama catalog lists the qwen3:1.7b download at approximately 1.4 GB when this draft was prepared. Download size is not total runtime memory: model state, context, the operating system, and the application need additional memory. An 8 GB RAM machine is a practical starting point, rather than a guaranteed minimum. Available memory and the selected context size matter. More memory or supported GPU acceleration can improve the experience; a small model can also run on CPU, with hardware-dependent latency. Do not compare this small teaching model's answer quality with a much larger hosted model and assume local execution caused the difference. Model capability and deployment location are separate choices. 3. Install Ollama and download the model Install Ollama using the instructions for your operating system in the official quickstart. On macOS and Windows, launch the installed application. On Linux, follow the service instructions provided by the installer. Verify the CLI: ollama --version Download the model: ollama pull qwen3:1.7b List installed models: ollama list Try a terminal conversation: ollama run qwen3:1.7b Ask: Explain an API in three short sentences. Exit the conversation with /bye. If the runtime is not running, start it in a separate terminal: ollama serve An address-in-use error can mean the existing Ollama application or service already owns the port. Check the running service before starting a second copy. 4. Understand the API before building the interface The chat endpoint accepts a model name and an array of messages. A message identifies a role and its content. { "model": "qwen3:1.7b", "messages": [ {"role": "system", "content": "Explain clearly and acknowledge uncertainty."}, {"role": "user", "content": "What is an API?"} ], "stream": false, "think": false } The system message expresses application guidance. User messages contain requests. Assistant messages contain earlier answers that we choose to send back. We disable streaming in the initial example so one request produces one complete JSON response. We also disable Qwen3's thinking mode to keep this first lab focused on visible answers. Thinking support and its controls depend on the model; this setting is not universal across all models. Use think only with a current Ollama version and a model that supports it. The chat API reference documents the request and response fields. 5. Create an isolated Python environment Create a folder named local-ai-chat and open a terminal inside it. On macOS or Linux: python3 -m venv .venv source .venv/bin/activate On Windows PowerShell: py -3.11 -m venv .venv .\.venv\Scripts\Activate.ps1 If PowerShell blocks activation, you can call the environment's Python directly rather than changing machine-wide security settings: .\.venv\Scripts\python.exe -m pip install streamlit In the activated environment, install Streamlit: python -m pip install streamlit The HTTP client in this lab uses Python's standard library, so there is no additional client dependency. For a published release, preserve the exact resolved dependency versions after validating the application: python -m pip freeze > requirements.txt A requirements file records Python packages. Record the Python version, Ollama version, and model identity separately; all can affect reproducibility. 6. Build the complete chat application Create app.py with this code: import json import time import urllib.error import urllib.request import streamlit as st ENDPOINT = "http://127.0.0.1:11434/api/chat" MODEL = "qwen3:1.7b" SYSTEM = ( "You are a helpful technical tutor. Explain clearly. " "When you are uncertain, say so. Do not invent citations." ) MAX_INPUT_CHARS = 2000 MAX_PREVIOUS_MESSAGES = 6 # Three complete user/assistant turns. def call_model(messages): payload = { "model": MODEL, "messages": messages, "stream": False, "think": False, "options": { "temperature": 0.2, "num_ctx": 4096, "num_predict": 512, }, } request = urllib.request.Request( ENDPOINT, data=json.dumps(payload).encode("utf-8"), headers={"Content-Type": "application/json"}, method="POST", ) with urllib.request.urlopen(request, timeout=180) as response: result = json.load(response) if result.get("error"): raise ValueError(str(result["error"])) answer = result.get("message", {}).get("content") if not isinstance(answer, str) or not answer.strip(): raise ValueError("The runtime returned no visible answer.") return answer, result st.set_page_config(page_title="Local AI Chat", page_icon="💬") st.title("Local AI Chat") st.caption(f"Model: {MODEL} · Runtime: Ollama · Local inference") if "messages" not in st.session_state: st.session_state.messages = [] if "last_run" not in st.session_state: st.session_state.last_run = None with st.sidebar: st.header("Conversation controls") st.write("Each request includes the last three completed turns.") if st.button("Clear conversation"): st.session_state.messages = [] st.session_state.last_run = None st.rerun() if st.session_state.last_run: st.subheader("Last successful request") st.json(st.session_state.last_run) for message in st.session_state.messages: with st.chat_message(message["role"]): st.markdown(message["content"]) prompt = st.chat_input("Ask a question") if prompt: prompt = prompt.strip() if not prompt: st.warning("Enter a question first.") st.stop() if len(prompt) > MAX_INPUT_CHARS: st.warning(f"Keep this lab's input under {MAX_INPUT_CHARS} characters.") st.stop() user_message = {"role": "user", "content": prompt} history = st.session_state.messages[-MAX_PREVIOUS_MESSAGES:] messages = [{"role": "system", "content": SYSTEM}, *history, user_message] with st.chat_message("user"): st.markdown(prompt) try: started = time.perf_counter() with st.chat_message("assistant"): with st.spinner("Generating locally..."): answer, result = call_model(messages) elapsed = time.perf_counter() - started st.markdown(answer) st.caption(f"Complete response received in {elapsed:.2f} seconds") except urllib.error.HTTPError as exc: st.error(f"Ollama returned HTTP {exc.code}. Check its logs and model name.") except urllib.error.URLError: st.error("Cannot reach Ollama. Check that the local runtime is running.") except (TimeoutError, OSError): st.error("The request timed out or the connection failed. Try a shorter input.") except (ValueError, KeyError, TypeError): st.error("The runtime returned an unexpected response. Check Ollama's logs.") else: # Commit only complete, successful turns to conversation history. st.session_state.messages.extend([ user_message, {"role": "assistant", "content": answer}, ]) st.session_state.last_run = { "elapsed_seconds": round(elapsed, 2), "input_tokens": result.get("prompt_eval_count"), "output_tokens": result.get("eval_count"), "done_reason": result.get("done_reason"), } st.rerun() Start the app, keeping Ollama running: python -m streamlit run app.py --server.address 127.0.0.1 --browser.gatherUsageStats false On Windows without activation, use .\.venv\Scripts\python.exe in place of python. Open localhost. You should see the chat title, input box, and conversation controls. The Ollama service is still a separate process. 7. Follow one request through the application Ask: Explain a reverse proxy using a simple example. The application strips whitespace, checks the input size, selects recent history, and adds the system message. Python serializes the request as JSON and sends it to the local runtime. Ollama performs inference and returns a JSON response. The application extracts the visible answer and commits a complete conversation turn to session state. That sequence exposes an important engineering boundary: generation is one operation inside a larger application flow. Input handling, state updates, error handling, and measurement remain our responsibility. Why save a turn only after success? Imagine that we save the user message, then the model request fails. The next request could inherit an unanswered turn. Repeated failures could create several adjacent user messages and confusing history. This app saves the user message and assistant answer together after a successful call. Failed attempts can be logged separately in a larger application, while the model-facing conversation stays coherent. 8. Conversation history is supplied context Ask these two questions in sequence: 1. My example application is a school admissions portal. Suggest three useful API endpoints. 2. Which of those should require authentication? The second question depends on the first. Our application makes the reference understandable by resending previous messages. Now clear the conversation and ask the second question again. The earlier context is absent. The model may ask for clarification or give a generic answer; the exact wording varies. The model's knowledge learned during training, the application's conversation history, and persistent user memory are different mechanisms. This lab implements temporary session history. It does not store a user profile or update model weights. Also notice that the interface displays the full session history while only the last three completed turns are sent. An old message being visible on screen does not mean it is in the model's current context. 9. Context limits: characters are only a rough guard We use three separate controls: | Control | Purpose | Limitation | | --- | --- | --- | | 2,000 input characters | Prevent very large individual submissions | Characters do not correspond directly to tokens | | Three previous turns | Keep history growth bounded for the lab | A fixed turn count can discard relevant information | | 4,096-token context setting | Request a bounded model context | It does not prove the constructed input fits | Tokens can be words, parts of words, punctuation, or other text units. Code, multilingual text, and tables tokenize differently. The assembled request includes instructions, history, the new question, and formatting overhead. A production application should budget using the selected model's tokenizer or a validated estimation strategy, reserve generation space according to runtime behavior, and remove or summarize context deliberately. Do not rely on silent truncation preserving the most important information. Our output cap also means a response can stop before it is complete. Inspect done_reason and the runtime's behavior before treating a short answer as a successful explanation. 10. Measure latency without inventing a benchmark The sidebar shows elapsed time and token counts from the most recent successful request. We measure time around the complete HTTP call. That includes runtime work and the response transfer. It is not time to first token because this version does not stream. The first request may involve loading the model. Later requests may benefit from a warm runtime. Compare multiple runs on the same hardware, with comparable inputs and output lengths, before drawing conclusions. For your own measurements, record the hardware, available memory, model identity, Ollama version, prompt, output length, and whether the runtime was warm. A single screenshot of a fast response is not a performance study. Low temperature can reduce variation in generation, but it does not make responses correct or guarantee identical results across runtimes and hardware. 11. Make failure part of the exercise Use these checks before calling the setup complete: | Exercise | What to check | | --- | --- | | Ask a short question | A nonempty answer appears and metrics update | | Ask a dependent follow-up | The response uses the recent conversation | | Clear the conversation | Messages and previous metrics disappear | | Submit over 2,000 characters | The app rejects the request before inference | | Stop Ollama and ask a question | An error appears; no failed turn enters saved history | | Ask for a fact about an unseen private document | Recognize that the model has no evidence from that document | The final exercise matters as much as the first. A fluent answer is not evidence that the application accessed a source or verified a claim. Our chat application has no retrieval layer, browser, or database tool. 12. Troubleshooting | Problem | Likely cause | Next action | | --- | --- | --- | | ollama command missing | Installation or PATH issue | Complete the OS-specific install and reopen the terminal | | Connection refused | Runtime unavailable | Launch Ollama or start its service | | HTTP error after model request | Missing model or incompatible request | Check ollama list, runtime logs, and installed version | | Model is very slow | CPU execution, memory pressure, or cold loading | Close heavy apps, shorten context, and compare warm runs | | streamlit is missing | Wrong Python environment | Install using the same Python that launches the app | | Answer ends abruptly | Output limit reached or generation stopped | Inspect the stop reason before raising the output cap | | Earlier details are forgotten | History window excluded them | Inspect the messages actually sent | We deliberately do not add automatic retries. Retrying a long generation can double work and hide persistent failure. If retries are added later, define which errors are transient and bound their number and total duration. 13. What changes for production? This lab teaches the basic request path. A shared service adds responsibilities: - Identity and isolation: authenticate users and isolate their conversation state. - Durability: persist conversations with retention and deletion rules instead of relying on session state. - Capacity: limit concurrent requests, apply backpressure, and handle cancellation. - Evaluation: test factual accuracy, task success, and regressions on representative examples. - Observability: track failures, token usage, latency, model versions, and request identifiers. - Evidence: add retrieval or tools when answers require information outside the supplied context. Local execution changes where inference happens. It does not automatically secure logs, browser sessions, or a publicly exposed service. Keep this lab bound to the loopback interface and use synthetic inputs while learning. Streaming would improve perceived responsiveness, but it introduces partial answers and cancellation behavior. Retrieval would add evidence, but also indexing, access controls, and evaluation. Tool calling would add actions, which require validation and permissions outside model instructions. Each extension is an engineering problem worth studying separately. 14. Try these small experiments Experiment A: Remove history. Send only the system message and new question. Compare dependent follow-ups with the original implementation. Experiment B: Change the output cap. Compare short and long requested explanations. Record token count, elapsed time, and whether the answer finishes. Experiment C: Compare instruction styles. Ask the same question with a tutor instruction and an incident-analysis instruction. Judge relevance and correctness separately from tone. Change one variable at a time. Otherwise, a better answer does not tell you which change helped. What we have built We now have a small application with explicit model input, bounded recent history, local inference, measurable request behavior, and visible failure handling. The chat window is the easiest part to see. The more useful understanding is underneath it: an application decides what context enters the model, how requests execute, and what happens when the result is unavailable or wrong. Next, we will add documents and build the first retrieval pipeline. That is where the question changes from “Can the model answer?” to “Did the system supply the evidence needed to answer?” References - Ollama quickstart - Ollama chat API - Qwen3 1.7B model catalog entry - Streamlit installation guide - Ollama source repository - Streamlit source repository

지금 만든 Python 코드 중 다른 사람도 버튼으로 쓰게 만들고 싶은 건 뭐야? 공식 저장소 streamlit/streamlit AI 활용 정보는 여기에도 모아둘게. discord.gg