Can [AI] be the all in one Assistant?

• CTA’s
  • Quieres el premium? No, correre el riesgo!
  • You don’t have to miss out
  • They all laugh when…
  • What sounds better than privacy?
  • Is your Business performing at 100%? Here is the best/easiest way to find out
    • Measure, Check, Act

With this code you can see all the models available at groqAPI.

And with this sample streamlit app - you can query each available model.

I was testing how each of them can perform to sample questions.

I called this my z_aigen stack in Portainer:

• The Container Image
• This is my AI-Gen docker Compose

version: '3.8'

services:
  phidata_service:
    image: ghcr.io/jalcocert/phidata:yt-groq #phidata:yt_summary_groq
    container_name: phidata_yt_groq
    ports:
      - "8502:8501"    
    environment:
      - GROQ_API_KEY="gsk_dummy-groq-api" # your_api_key_here
    command: streamlit run cookbook/llms/groq/video_summary/app.py
    restart: always
    networks:
      - cloudflare_tunnel

  streamlit_multichat:
    image: ghcr.io/jalcocert/streamlit-multichat:latest
    container_name: streamlit_multichat
    volumes:
      - ai_streamlit_multichat:/app
    working_dir: /app
    command: /bin/sh -c "\
            mkdir -p /app/.streamlit && \
            echo 'OPENAI_API_KEY = "sk-dummy-openai-key"' > /app/.streamlit/secrets.toml && \
            echo 'GROQ_API_KEY = "dummy-groq-key"' >> /app/.streamlit/secrets.toml && \
            echo 'ANTHROPIC_API_KEY = "sk-dummy-anthropic-key"' >> /app/.streamlit/secrets.toml && \
            streamlit run Z_multichat_Auth.py
    ports:
      - "8501:8501"
    networks:
      - cloudflare_tunnel
    restart: always
      # - nginx_default   

  ollama:
    image: ollama/ollama
    container_name: ollama
    ports:
      - "11434:11434" #Ollama API
    volumes:
      #- ollama_data:/root/.ollama
      - /home/Docker/AI/Ollama:/root/.ollama
    networks:
      - ollama_network      

  ollama-webui:
    image: ghcr.io/ollama-webui/ollama-webui:main
    container_name: ollama-webui
    ports:
      - "3000:8080" # 3000 is the UI port
    environment:
      - OLLAMA_BASE_URL=http://192.168.3.200:11434
    # add-host:
    #   - "host.docker.internal:host-gateway"
    volumes:
      - /home/Docker/AI/OllamaWebUI:/app/backend/data
    restart: always          
    networks:
      - ollama_network    

networks:
  cloudflare_tunnel:
    external: true
  ollama_network:
    external: false
  # nginx_default:
  #   external: true

volumes:
  ai_streamlit_multichat:

• https://console.groq.com/docs/examples
• https://github.com/groq/groq-api-cookbook
• https://console.groq.com/playground
  • https://pypi.org/project/groq/
  • https://github.com/groq/groq-python

It has Speech capabilities like transcriptions & Translations!

And ofc, vision, with Llama 3.2 Vision at this moment.

For passing important variables (like API keys)

• We could do it via the ./streamlit/secrets.toml file, with this kind of command at the docker compose
• But, they can also be passed as environment variables, with this kind of docker-compose

Pros

1. It just require a single additional file to bring Auth to the App
2. Completely Free and no dependencies with 3rd parties Cons
3. Hardcoded values (~Okeish for a PoC)

• Example in Streamlit-Multichat - A very simple one that allow certain user/passwords to access an app

Thanks to Naashonomics and the code

• Pros

1. Integrated with MailerLite API

• With double opt-in, you will get just verified emails

2. No hardcoded values in the app

• Cons MailerLite Free Tier finishes at 1k subs
• Example Code in CV-Check - A very simple one that allow certain user/passwords to access an app

FormBricks is an open source Survey Platform.

You can make very interesting polls and embedd them or reference them with a link into your Apps. The Survey Type Link Survey was very helpful for this case.

It has very cool integrations, like with GSheets, which you can use:

• Pros

1. Integrated with MailerLite API

• With MailerLite double opt-in, you will get just verified emails
• You can use Formbricks as another EmailWall with the GSheets integration

2. No hardcoded values in the app

• Cons MailerLite Free Tier finishes at 1k subs

Example Code here. This module for MailerLite and this one for FormBricks via GSheets

• Pros

1. Integrated with Stripe API
2. No hardcoded values in the app, get all the clients
3. You can check if a certain mail has any active/trialing subscription
4. Or if it has a specific subscription

• Cons
• 3rd parties dependencies
• No email verification - but card verification
• No password verification for a given email

This module checks if a given email has ever been a customer / have active subscription / have particular products_id subs

I read that it is a little bit tricky to implement.

Maybe they are not there yet?

Streamlit Roadmap

• https://github.com/kajarenc/stauthlib
  • Google Auth done easy?
• Folium Maps Selections with pydeck_chart and apparently working with streamlit-folium too
  • https://github.com/streamlit/streamlit/pull/9377
  • Sample in the docs, which i tried and it works with pydeck
• Pure html to streamlit app - Ready from v1.40.0
  • st.html content is not iframed. Executing JavaScript is not supported at this time.
• Charts Selections!!
• There are now widgets for both, audio_input and camera_input
  • It resonates a lot with Speech-Rater and with Computer Vision

https://github.com/streamlit/cookbook, I tried many of these during the testing phase for AIssistant

A Trick for seeing which packages have actually been installed from the ones at requirements.txt

#pip install -r requirements.txt

#pip freeze | grep -E '^(anthropic|streamlit)=='
#pip freeze | grep -Ff requirements.txt
pip freeze | grep -E "^($(paste -sd '|' requirements.txt))=="

Ive summarized some interesting articles. Using this script (FireCrawl+OpenAI)

More Diagrams: GraphViz

If MermaidJs, and Python Diagrams was not enough.

Well, and DrawIO…

Then we have GraphViz.

Overview: Graphviz is a powerful open-source graph visualization software that uses the DOT language to define graphs. It is widely used for generating complex network, flow, and structural diagrams.

Primary Focus: Graphviz is focused on graph-based representations, such as flowcharts, state diagrams, network graphs, organizational charts, and dependency graphs.

Syntax: Graphviz uses the DOT language, which is a declarative, text-based format. It describes the nodes and edges in a graph with rich options for styling.

There is a live editor for GraphViz: http://www.webgraphviz.com/

Features:

Complex Layouts: Graphviz supports automatic layout algorithms to position nodes, such as hierarchical, radial, and circular layouts.
Advanced Styling: It offers a variety of options for styling nodes, edges, and labels, including colors, shapes, and gradients.
Performance: Graphviz is optimized for rendering large graphs, making it suitable for generating complex visualizations.
Rendering: It can output in various formats such as PNG, SVG, PDF, and more.

LocalStack - A Replacement for AWS 😲

LocalStack is a tool designed for developers who want to test AWS functionalities locally. It provides an emulated environment of AWS services, solving issues related to unpredictable billing and resource management during development.

• Purpose: LocalStack emulates AWS API functionality.
• Problem Solved: Allows local testing without involving AWS services directly.
• Installation:
  • Sign up with a GitHub account.
  • Use brew install localstack/tap/localstack-cli for installation on macOS.
  • Requires Docker to function as a local “mini-cloud” operating system.
• Basic Use:
  • Set environment variables for AWS access.
  • Create services like S3 buckets using standard AWS commands.
  • Offers a Community Image for free usage.
• Limitations:
  • Not all AWS services are fully emulated; some are available only in the Pro version.
  • Works with a single API endpoint unlike AWS’s regional separation.
• Key Features:
  • Supports essential services like EC2.
  • Allows basic CRUD operations.
  • Requires understanding of feature coverage before use.

LocalStack is crucial for developers needing a local AWS-like environment without the complexities of AWS billing.

Conclusion: LocalStack is essential for developers needing local AWS API testing without unpredictable costs. It simplifies local development workflows.

Code2prompt 😲

code2prompt is a command-line tool designed to transform codebases into structured LLM prompts.

This project addresses the cumbersome task of generating prompts for LLMs from code.

It automates the collection and formatting of code, making it easier to interact with models like GPT and Claude.

Key features include:

• Converts entire codebases into a single prompt.

• Utilizes Handlebars templates for customizable prompt generation.

• Respects .gitignore and allows file filtering with glob patterns.

• Displays token count for generated prompts.

• Supports copying prompts to clipboard and saving them to files.

• Generates Git commit messages and pull request descriptions from staged files.

• Offers built-in templates for various use cases (e.g., documenting code, finding vulnerabilities).

Installation options available include:

1. Binary Releases: Download from the Releases page.

2. Source Build: Requires Git, Rust, and Cargo.

3. Cargo: Install via cargo install code2prompt.

4. AUR: Available for Arch Linux users.

5. Nix: Can be installed using nix-env.

Usage is straightforward, allowing users to generate prompts from their codebase with optional filters and custom templates.

The tool helps streamline LLM prompt creation, enhancing productivity for developers.

In conclusion, code2prompt simplifies the process of creating prompts from codebases, making LLM interactions efficient.

Similar projects include CodeGPT and Code2Flow.

And on the way Ive improved the Article/GH Summarizer with v3b

• https://github.com/latitude-dev/latitude-llm

Latitude is an open-source prompt engineering platform designed to streamline AI feature development.

It addresses the following problems:

• Managing prompts can be cumbersome when they’re embedded in code.
• Testing AI outputs can be inconsistent and challenging.
• Analyzing performance metrics of AI models requires a centralized tool.

As per the docs, for now SDKs are Rust or JS/TS

Key Features:

• Collaborative Prompt Management: Enables team collaboration on prompt development.

• Testing and Validation: Uses LLMs to verify AI responses for accuracy and relevance.

• Performance Insights: Provides analytics on response times and cost comparisons.

• Version Control: Tracks changes in prompts for better management.

• API and SDK Support: Facilitates easy integration into existing systems.

• Open-Source Community Driven: Encourages contributions and improvements from users.

Deployment Options:

1. Latitude Cloud: Managed solution for quick setup.

2. Latitude Self-Hosted: Open-source version for greater control and customization.

Community Engagement:

• A vibrant community on Slack for support and collaboration.

• Contributions are welcomed to enhance the platform.

In conclusion, Latitude simplifies the process of integrating AI into products while facilitating ongoing evaluation and improvement.

Similar Projects: TBC

• https://github.com/latitude-dev/latitude

Latitude is an open-source framework created to simplify embedded analytics by providing a powerful analytics layer between databases and end-users. It allows developers to integrate data analytics into applications efficiently without requiring deep expertise in database management or visualization.

Among other DBs, latitude works with SQLite!

Key Features:

• Database Connectivity: Latitude can connect to a variety of databases and data warehouses, providing flexibility for different environments and data sources.
• Parameterized SQL Queries as API Endpoints: It allows users to create parameterized SQL queries and expose them as API endpoints, making it easy to query data dynamically and integrate with other systems.
• Interactive Visualizations: Latitude supports interactive data visualizations in frontend frameworks (such as React, Svelte, and Vue), or alternatively, it can display them within iframes for easy embedding in web pages.
• Caching for Performance: The framework includes built-in caching, which optimizes query performance and reduces the load on databases by storing previously queried results.
• Security: Latitude is SSL-ready and includes protections against SQL injection, ensuring secure communication between the client and the database.
• Community-driven: The project encourages contributions from developers, fostering an active open-source community.

Use Cases:

• Quick Dashboard Creation: Developers can rapidly build dashboards and visualizations, allowing end-users to explore and interact with data without extensive custom development.
• Single-command Deployment: Latitude can be deployed quickly with a single command, making it easier for developers to get up and running without complex configurations.
• Framework Integration: Latitude integrates seamlessly with popular frontend frameworks like React, Svelte, and Vue, which are commonly used for building modern web applications.

Community and Support:

• Latitude has an active community on Slack, where developers can collaborate, share insights, and get support.
• Comprehensive documentation is available to guide users through the setup process and help with integration into various systems.

Current Status:

• The project is no longer maintained as the focus has shifted to a new project, Latitude LLM, which likely focuses on new features or different capabilities.
• Existing users can still use the codebase and license as-is, though no new updates are being released.

Conclusion: Latitude simplifies the integration of embedded analytics for developers, allowing for easy creation and deployment of dashboards, visualizations, and queries. Its simplicity and integration with modern frontend frameworks make it a valuable tool for building analytics-rich applications.

Similar projects to Latitude include:

• Superset: An open-source data visualization tool that allows users to create and share dashboards.
• Metabase: Another open-source analytics platform that focuses on simple setup and user-friendly dashboards.

GNews - https://github.com/ranahaani/GNews

• Summary:
  GNews is a lightweight Python package that provides an API to search for articles on Google News, returning results in JSON format. It supports fetching articles by keywords, topics, and locations, making it versatile for news aggregation.

• Key Features:

  • Lightweight: Easy to use with minimal setup.
  • Integration: Fetches articles directly from Google News RSS Feed.
  • Global Support: Covers over 141 countries and 41 languages.
  • Structured Results: Returns data in JSON format for easy parsing.

• Pros:

  • Simple Installation: No complex dependencies.
  • Convenience: Eliminates the need for custom scrapers.
  • Flexible Searches: Supports a variety of search parameters.

• Cons:

  • Limited Sources: Only fetches from Google News.
  • Dependency: Relies on the availability of Google News RSS feeds.

• Alternatives:

  • NewsAPI
  • ContextualWeb News API
  • Bing News Search API

From Perplexica to OpenSearch GPT [AI Search Engines!] - https://github.com/supermemoryai/opensearch-ai

OpenSearch GPT, an open-source, AI-powered search engine that personalizes search results by learning from user interactions. It emphasizes key features like its Mem Zero memory system for remembering past interactions, its robust technological framework, and its versatility as a tool for writing assistance and data management.

OpenSearch GPT aims to enhance productivity and streamline workflows, offering transparency and flexibility as an alternative to proprietary search engines.

Key Points

• Personalization: Delivers tailored search results by learning from user behavior.
• Memory System: Includes Mem Zero to retain past interactions and improve relevance.
• Technology Framework: Built using Versal AI ADK and Next.js for a robust experience.
• Versatility: Functions as a writing assistant and supports data management tasks.
• Open Source: Provides transparency and customization options for users.

Pros and Cons

Pros:

• Highly personalized search experience.
• Open-source design allows community involvement and customization.
• Supports a range of functionalities for diverse use cases.

Cons:

• Requires Google account sign-in to access the platform.
• May pose a learning curve for users new to open-source tools.

Alternatives

• Perplexity AI
• OpenAI’s Search Engine Prototype

A sample API call to OpenAI>1, for example to create tickets

But, the user/system prompts can be better modularized if we go with this approach of the markdown summarizer

Sample Anthropic Claude Models API call

See their docs for more examples

Anthropic API calls first tested during StreamlitMultichat

• Opus models are the most powerful, but Sonnet LLMs are a balance between speed/cost/quality of the reply
• There is alrady Vision and Computer Use capabilities in beta…

Sample Groq Models API call

See available models via groq API

1. Setup Ollama
2. Download a LLM via Ollama
3. Use this sample script to query the LLM via Ollama Python API

Ollama API calls first tested during StreamlitMultichat