Spaces:
Sleeping
Sleeping
| import logging | |
| import os | |
| import streamlit as st | |
| from dotenv import load_dotenv | |
| import openai | |
| from langchain_openai import ChatOpenAI | |
| from langchain_community.vectorstores import FAISS | |
| from langchain_openai import OpenAIEmbeddings | |
| from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder | |
| from langchain.text_splitter import RecursiveCharacterTextSplitter | |
| from urllib.parse import quote, urlparse | |
| from langchain.agents import tool, AgentExecutor | |
| from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser | |
| from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages | |
| from langchain_core.messages import AIMessage, HumanMessage | |
| from langchain_community.document_loaders import TextLoader | |
| from langchain_text_splitters import CharacterTextSplitter | |
| import serpapi | |
| import requests | |
| import streamlit.components.v1 as components | |
| import smtplib | |
| from email.mime.multipart import MIMEMultipart | |
| from datetime import datetime | |
| import pandas as pd | |
| import re | |
| from io import BytesIO | |
| import base64 | |
| import random | |
| from bs4 import BeautifulSoup | |
| import smtplib | |
| from email.mime.multipart import MIMEMultipart | |
| from email.mime.text import MIMEText | |
| from markdownify import markdownify | |
| import chargebee | |
| import pyrebase # ✅ Correct | |
| import streamlit.components.v1 as components | |
| import time | |
| import warnings | |
| from streamlit.components.v1 import html | |
| from langchain.docstore.document import Document | |
| import firebase_admin | |
| import uuid | |
| import json | |
| import io | |
| from firebase_admin import credentials, firestore | |
| import base64 | |
| from pdfminer.high_level import extract_text # Import for PDF text extraction | |
| from PIL import Image | |
| st.set_page_config(layout="wide") | |
| import logging | |
| import asyncio | |
| import re | |
| import docx | |
| from langchain_community.tools import TavilySearchResults | |
| import docx | |
| from docx import Document as DocxDocument | |
| from typing import List, Optional | |
| from openai import OpenAI | |
| import numpy as np # ✅ Import NumPy | |
| import hashlib | |
| # Set up logging to suppress Streamlit warnings about experimental functions | |
| logging.getLogger('streamlit').setLevel(logging.ERROR) | |
| if "documents" not in st.session_state: | |
| st.session_state["documents"] = {} | |
| if "chat_history" not in st.session_state: | |
| st.session_state["chat_history"] = [] | |
| if "message_limit" not in st.session_state: | |
| st.session_state["message_limit"] = 0 | |
| if "used_messages" not in st.session_state: | |
| st.session_state["used_messages"] = 0 | |
| if "faiss_db" not in st.session_state: | |
| st.session_state["faiss_db"] = None | |
| # Initialize logging and load environment variables | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger(__name__) | |
| load_dotenv() | |
| # Initialize Firebase | |
| firebase = pyrebase.initialize_app(firebase_config) | |
| db = firebase.database() | |
| storage = firebase.storage() | |
| backend_url = "https://backend-web-05122eab4e09.herokuapp.com" | |
| def display_save_confirmation(type_saved): | |
| """ | |
| Display a confirmation message when content is saved. | |
| """ | |
| st.info(f"Content successfully saved as **{type_saved}**!") | |
| def convert_file_to_txt(file): | |
| """ | |
| Convert different file types to plain text. | |
| """ | |
| if file.type == "application/pdf": | |
| return convert_pdf_to_txt(file) | |
| elif file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document": | |
| return convert_docx_to_txt(file) | |
| elif file.type == "text/plain": | |
| return convert_txt_to_txt(file) | |
| elif file.type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": | |
| return convert_excel_to_txt(file) | |
| elif file.type == "text/csv": | |
| return convert_csv_to_txt(file) | |
| else: | |
| st.sidebar.warning(f"Unsupported file type: {file.type}") | |
| return None | |
| def convert_pdf_to_txt(file): | |
| """ | |
| Convert a PDF file to plain text. | |
| """ | |
| try: | |
| text = extract_text(file) # Use PyPDF2 or pdfplumber for better accuracy if needed | |
| return text.strip() | |
| except Exception as e: | |
| st.sidebar.error(f"Error converting PDF to TXT: {e}") | |
| return None | |
| def convert_docx_to_txt(file): | |
| """ | |
| Extract text from a .docx file. | |
| """ | |
| try: | |
| doc = docx.Document(file) | |
| text = "\n".join([paragraph.text for paragraph in doc.paragraphs]) | |
| return text.strip() | |
| except Exception as e: | |
| st.sidebar.error(f"Error converting DOCX to TXT: {e}") | |
| return None | |
| def convert_txt_to_txt(file): | |
| """ | |
| Handle plain text file as is. | |
| """ | |
| try: | |
| text = file.read().decode("utf-8") | |
| return text.strip() | |
| except Exception as e: | |
| st.sidebar.error(f"Error reading TXT file: {e}") | |
| return None | |
| def convert_excel_to_txt(file): | |
| """ | |
| Convert an Excel file to plain text. | |
| """ | |
| try: | |
| df = pd.read_excel(file) | |
| text = df.to_string(index=False) | |
| return text.strip() | |
| except Exception as e: | |
| st.sidebar.error(f"Error converting Excel to TXT: {e}") | |
| return None | |
| def convert_csv_to_txt(file): | |
| """ | |
| Convert a CSV file to plain text. | |
| """ | |
| try: | |
| df = pd.read_csv(file) | |
| text = df.to_string(index=False) | |
| return text.strip() | |
| except Exception as e: | |
| st.sidebar.error(f"Error converting CSV to TXT: {e}") | |
| return None | |
| def merge_markdown_contents(contents): | |
| """ | |
| Merge multiple Markdown contents into a single Markdown string. | |
| """ | |
| merged_content = "\n\n---\n\n".join(contents) | |
| return merged_content | |
| def upload_to_firebase(user_id, file): | |
| """ | |
| Upload document to Firebase, extract content, and add it to the knowledge base. | |
| """ | |
| content = convert_file_to_txt(file) # Ensure this function extracts content correctly | |
| if not content: | |
| return None, "Failed to extract content from the file." | |
| existing_files = st.session_state.get("documents", {}) | |
| for doc_id, doc_data in existing_files.items(): | |
| if doc_data["name"] == file.name and doc_data["content"] == content: | |
| return None, f"File '{file.name}' already exists." | |
| doc_id = str(uuid.uuid4()) | |
| document_data = {"content": content, "name": file.name} | |
| # Save document to Firebase | |
| user_data = db.child("users").child(user_id).get().val() | |
| business_data = db.child("business_accounts").child(user_id).get().val() | |
| if user_data: | |
| db.child("users").child(user_id).child("KnowledgeBase").child(doc_id).set(document_data) | |
| if business_data: | |
| db.child("business_accounts").child(user_id).child("KnowledgeBase").child(doc_id).set(document_data) | |
| fetch_documents(user_id) | |
| # Add content to the knowledge base | |
| if "knowledge_base" not in st.session_state: | |
| st.session_state["knowledge_base"] = [] | |
| st.session_state["knowledge_base"].append({"doc_id": doc_id, "content": content}) | |
| # Index the document content for semantic search | |
| index_document_content(content, doc_id) | |
| st.sidebar.success(f"Document '{file.name}' uploaded successfully and added to the knowledge base!") | |
| return content, None | |
| def index_document_content(doc_content, doc_id): | |
| """ | |
| Indexes the document content by splitting it into chunks and creating embeddings. | |
| """ | |
| text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=500) | |
| texts = text_splitter.split_text(doc_content) | |
| # Create embeddings for each chunk | |
| embeddings = OpenAIEmbeddings(model="text-embedding-3-large", api_key=client) | |
| doc_metadata = [{"doc_id": doc_id, "chunk_id": i} for i in range(len(texts))] | |
| vector_store = FAISS.from_texts(texts, embeddings, metadatas=doc_metadata) | |
| # Save the vector store in session state | |
| if "vector_store" not in st.session_state: | |
| st.session_state["vector_store"] = {} | |
| st.session_state["vector_store"][doc_id] = vector_store | |
| def fetch_trustbuilders(user_id): | |
| """ | |
| Retrieve TrustBuilders from Firebase for a specific user. | |
| """ | |
| try: | |
| trustbuilders = db.child("users").child(user_id).child("TrustBuilders").get().val() | |
| if trustbuilders: | |
| # Extract content from TrustBuilders | |
| return [tb["content"] for tb in trustbuilders.values()] | |
| else: | |
| st.warning("No TrustBuilders found in Firebase.") | |
| return [] | |
| except Exception as e: | |
| st.error(f"Error fetching TrustBuilders: {e}") | |
| return [] | |
| def delete_trustbuilder(user_id, trustbuilder_id): | |
| try: | |
| db.child("users").child(user_id).child("TrustBuilder").child(trustbuilder_id).remove() | |
| st.success("TrustBuilder deleted successfully.") | |
| st.rerun() | |
| except Exception as e: | |
| st.error(f"Error deleting TrustBuilder: {e}") | |
| # Define and validate API keys | |
| openai_api_key = os.getenv("OPENAI_API_KEY") | |
| serper_api_key = os.getenv("SERPER_API_KEY") | |
| if not openai_api_key or not serper_api_key: | |
| logger.error("API keys are not set properly.") | |
| raise ValueError("API keys for OpenAI and SERPER must be set in the .env file.") | |
| openai.api_key = openai_api_key | |
| st.markdown(""" | |
| <style> | |
| .custom-image img { | |
| width: 100px; /* Set the width to make the image smaller */ | |
| height: auto; /* Keep the aspect ratio */ | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| if "chat_started" not in st.session_state: | |
| st.session_state["chat_started"] = False | |
| if 'previous_trust_tip' not in st.session_state: | |
| st.session_state.previous_trust_tip = None | |
| if 'previous_suggestion' not in st.session_state: | |
| st.session_state.previous_suggestion = None | |
| if 'used_trust_tips' not in st.session_state: | |
| st.session_state.used_trust_tips = set() | |
| if 'used_suggestions' not in st.session_state: | |
| st.session_state.used_suggestions = set() | |
| # Suppress Streamlit deprecation and warning messages | |
| def copy_to_clipboard(text): | |
| """Creates a button to copy text to clipboard.""" | |
| escaped_text = text.replace('\n', '\\n').replace('"', '\\"') | |
| copy_icon_html = f""" | |
| <style> | |
| .copy-container {{ | |
| position: relative; | |
| margin-top: 10px; | |
| padding-bottom: 30px; /* Space for the button */ | |
| font-size: 0; /* Hide extra space */ | |
| }} | |
| .copy-button {{ | |
| background: none; | |
| border: none; | |
| color: #808080; /* Grey color */ | |
| cursor: pointer; | |
| font-size: 18px; /* Adjust icon size */ | |
| position: absolute; | |
| bottom: 0; | |
| right: 0; | |
| }} | |
| .copy-button:hover {{ | |
| color: #606060; /* Darker grey on hover */ | |
| }} | |
| .copy-message {{ | |
| font-size: 12px; | |
| color: #4CAF50; | |
| margin-left: 10px; | |
| display: none; | |
| }} | |
| </style> | |
| <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css"> | |
| <div class="copy-container"> | |
| <button class="copy-button" onclick="copyToClipboard()"> | |
| <i class="fas fa-copy"></i> | |
| </button> | |
| <span class="copy-message" id="copy_message">Copied!</span> | |
| </div> | |
| <script> | |
| function copyToClipboard() {{ | |
| var textArea = document.createElement("textarea"); | |
| textArea.value = "{escaped_text}"; | |
| document.body.appendChild(textArea); | |
| textArea.select(); | |
| document.execCommand("copy"); | |
| document.body.removeChild(textArea); | |
| var copyMessage = document.getElementById("copy_message"); | |
| copyMessage.style.display = "inline"; | |
| setTimeout(function() {{ | |
| copyMessage.style.display = "none"; | |
| }}, 2000); | |
| }} | |
| </script> | |
| """ | |
| components.html(copy_icon_html, height=60) | |
| def send_feedback_via_email(name, email, feedback): | |
| """Sends an email with feedback details.""" | |
| smtp_server = 'smtp.office365.com' | |
| smtp_port = 465 # Typically 587 for TLS, 465 for SSL | |
| smtp_user = os.getenv("EMAIL_ADDRESS") | |
| smtp_password = os.getenv("Password") | |
| msg = MIMEMultipart() | |
| msg['From'] = smtp_user | |
| msg['To'] = "wajahat698@gmail.com" | |
| msg['Subject'] = 'Feedback Received' | |
| body = f"Feedback received from {name}:\n\n{feedback}" | |
| msg.attach(MIMEText(body, 'plain')) | |
| try: | |
| with smtplib.SMTP(smtp_server, smtp_port, timeout=10) as server: | |
| server.set_debuglevel(1) # Enable debug output for troubleshooting | |
| server.starttls() | |
| server.login(smtp_user, smtp_password) | |
| server.sendmail(smtp_user, email, msg.as_string()) | |
| st.success("Feedback sent via email successfully!") | |
| except smtplib.SMTPConnectError: | |
| st.error("Failed to connect to the SMTP server. Check server settings and network connectivity.") | |
| except smtplib.SMTPAuthenticationError: | |
| st.error("Authentication failed. Check email and password.") | |
| except Exception as e: | |
| st.error(f"Error sending email: {e}") | |
| def extract_name(email): | |
| return email.split('@')[0].capitalize() | |
| def clean_text(text): | |
| """ | |
| Cleans and formats the LLM output for display in Streamlit. | |
| Returns the cleaned text for further use. | |
| """ | |
| # Step 1: Replace newline characters | |
| text = text.replace('\\n', '\n') | |
| # Step 2: Remove all HTML tags and remaining `<` or `>` characters | |
| text = re.sub(r'<[^>]*>', '', text) | |
| text = text.replace('<', '').replace('>', '') | |
| text = re.sub(r'<[^>]+>', '', text) | |
| # Step 3: Fix broken numbers and words, remove unnecessary spans | |
| text = re.sub(r'(\d+)\s*(B|M|T|billion|million|trillion)', lambda m: f"{m.group(1)} {m.group(2)}", text) | |
| text = re.sub(r'(\d)\s*([a-zA-Z])', r'\1 \2', text) # Fix numbers next to letters | |
| text = re.sub(r'(\d+)\s+([a-zA-Z])', r'\1 \2', text) # Fix broken numbers and words | |
| text = re.sub(r'<span class="(mathnormal|mord)">.*?</span>', '', text, flags=re.DOTALL) | |
| # Step 4: Split into paragraphs and clean each paragraph | |
| paragraphs = text.split('\n\n') | |
| cleaned_paragraphs = [] | |
| for paragraph in paragraphs: | |
| lines = paragraph.split('\n') | |
| cleaned_lines = [] | |
| for line in lines: | |
| # Preserve bold formatting for headings | |
| if line.strip().startswith('**') and line.strip().endswith('**'): | |
| cleaned_line = line.strip() | |
| else: | |
| # Remove asterisks, special characters, and fix merged text | |
| cleaned_line = re.sub(r'\*|\−|\∗', '', line) | |
| cleaned_line = re.sub(r'([a-z])([A-Z])', r'\1 \2', cleaned_line) | |
| # Handle bullet points | |
| if cleaned_line.strip().startswith('-'): | |
| cleaned_line = '\n' + cleaned_line.strip() | |
| cleaned_lines.append(cleaned_line) | |
| cleaned_paragraph = '\n'.join(cleaned_lines) | |
| cleaned_paragraphs.append(cleaned_paragraph) | |
| # Join cleaned paragraphs | |
| cleaned_text = '\n\n'.join(para for para in cleaned_paragraphs if para) | |
| # Step 5: Return cleaned and formatted text | |
| if re.search(r"\$.*?\$", cleaned_text): # Check for inline LaTeX | |
| return cleaned_text # Return cleaned text for inline LaTeX | |
| elif re.search(r"\\\[.*?\\\]", cleaned_text) or re.search(r"\\\(.*?\\\)", cleaned_text): # Check for block LaTeX | |
| return cleaned_text # Return cleaned text for block LaTeX | |
| elif "$" in cleaned_text: # Handle dollar signs in regular text | |
| return cleaned_text.replace("$", "\\$") # Return escaped text | |
| else: # Default case | |
| return cleaned_text | |
| def get_trust_tip_and_suggestion(): | |
| trust_tip = random.choice(trust_tips) | |
| suggestion = random.choice(suggestions) | |
| return trust_tip, suggestion | |
| from langchain.text_splitter import RecursiveCharacterTextSplitter | |
| def extract_text_from_docx(file_path): | |
| """Extract and return structured text from a .docx file, including tables.""" | |
| try: | |
| doc = DocxDocument(file_path) | |
| extracted_content = [] | |
| # Extract paragraphs | |
| for para in doc.paragraphs: | |
| if para.text.strip(): | |
| extracted_content.append(para.text.strip()) | |
| # Extract tables | |
| for table in doc.tables: | |
| for row in table.rows: | |
| row_data = [cell.text.strip() for cell in row.cells if cell.text.strip()] | |
| if row_data: | |
| extracted_content.append(" | ".join(row_data)) # Format as table row | |
| return "\n\n".join(extracted_content) # Return structured text | |
| except Exception as e: | |
| print(f"Error extracting DOCX: {e}") | |
| return "" | |
| def extract_text_from_md(md_file): | |
| """Extract text from a Markdown file.""" | |
| try: | |
| with open(md_file, "r", encoding="utf-8") as file: | |
| return file.read() | |
| except Exception as e: | |
| print(f"Error reading Markdown file: {e}") | |
| return "" | |
| def load_main_data_source(): | |
| """ | |
| Load the main data source from DOCX or Markdown, extract text, | |
| structure it properly, and return Document objects. | |
| """ | |
| try: | |
| file_path = "./data_source/time_to_rethink_trust_book.md" | |
| if not os.path.exists(file_path): | |
| print("❌ Error: File not found.") | |
| return [] | |
| # Determine file type and extract text accordingly | |
| if file_path.endswith(".docx"): | |
| file_text = extract_text_from_docx(file_path) | |
| elif file_path.endswith(".md"): | |
| file_text = extract_text_from_md(file_path) | |
| else: | |
| print("❌ Unsupported file format.") | |
| return [] | |
| if not file_text: | |
| print("⚠️ Warning: Extracted content is empty.") | |
| return [] | |
| # Split text into chunks | |
| text_splitter = RecursiveCharacterTextSplitter( | |
| chunk_size=1500, # Keep large sections intact | |
| chunk_overlap=200, # Large overlap for context retention | |
| ) | |
| main_texts = text_splitter.split_text(file_text) | |
| # Convert into Document objects | |
| main_documents = [Document(page_content=text) for text in main_texts] | |
| return main_documents | |
| except Exception as e: | |
| print(f"Unexpected error loading data: {e}") | |
| return [] | |
| def refresh_main_faiss_index(): | |
| """Load the main data source and store it permanently in FAISS.""" | |
| main_sources = load_main_data_source() | |
| if not main_sources: | |
| print("❌ No main data source found. FAISS index was NOT updated.") | |
| return | |
| embeddings = OpenAIEmbeddings() | |
| st.session_state["main_faiss_db"] = FAISS.from_documents(main_sources, embeddings) | |
| num_docs = len(st.session_state["main_faiss_db"].docstore._dict) | |
| def refresh_faiss_index(selected_doc_id=None): | |
| """Refresh FAISS index while keeping the main knowledge base intact.""" | |
| if selected_doc_id is None: | |
| return | |
| if "documents" not in st.session_state or selected_doc_id not in st.session_state["documents"]: | |
| return | |
| doc_content = st.session_state["documents"][selected_doc_id]["content"] | |
| if not doc_content.strip(): | |
| print(f"⚠️ Warning: Selected document {selected_doc_id} is empty.") | |
| return | |
| # Create embeddings and index only the selected document | |
| embeddings = OpenAIEmbeddings(model="text-embedding-3-large", api_key=client) | |
| text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=500) | |
| texts = text_splitter.split_text(doc_content) | |
| doc_metadata = [{"doc_id": selected_doc_id, "chunk_id": i} for i in range(len(texts))] | |
| new_vector_store = FAISS.from_texts(texts, embeddings, metadatas=doc_metadata) | |
| # Merge into session state FAISS index (separate from main knowledge base) | |
| if "faiss_db" in st.session_state and st.session_state["faiss_db"] is not None: | |
| old_db = st.session_state["faiss_db"] | |
| old_db.merge_from(new_vector_store) # ✅ Merge only the selected document | |
| st.session_state["faiss_db"] = old_db | |
| else: | |
| st.session_state["faiss_db"] = new_vector_store # ✅ Store only the selected doc | |
| num_docs = len(st.session_state["faiss_db"].docstore._dict) | |
| def store_brand_tonality(user_id, message): | |
| try: | |
| tonality_id = str(uuid.uuid4()) | |
| # Save to Firebase | |
| db.child("users").child(user_id).child("BrandTonality").child(tonality_id).set({"message": message}) | |
| # Update `st.session_state` for immediate sidebar display | |
| if "BrandTonality" not in st.session_state: | |
| st.session_state["BrandTonality"] = {} | |
| st.session_state["BrandTonality"][tonality_id] = {"message": message} | |
| # Confirmation | |
| display_save_confirmation("Brand Tonality") | |
| except Exception as e: | |
| st.error(f"Error saving Brand Tonality: {e}") | |
| def store_trustbuilder(user_id, message): | |
| try: | |
| trustbuilder_id = str(uuid.uuid4()) | |
| # Save to Firebase | |
| db.child("users").child(user_id).child("TrustBuilder").child(trustbuilder_id).set({"message": message}) | |
| # Update `st.session_state` for immediate sidebar display | |
| if "TrustBuilder" not in st.session_state: | |
| st.session_state["TrustBuilder"] = {} | |
| st.session_state["TrustBuilder"][trustbuilder_id] = {"message": message} | |
| # Confirmation | |
| display_save_confirmation("TrustBuilder") | |
| except Exception as e: | |
| st.error(f"Error saving TrustBuilder: {e}") | |
| def load_user_content(user_id): | |
| """ | |
| Load all content for a user from Firebase, ensuring each user has a single root | |
| containing TrustBuilder, BrandTonality, and other data fields like email, message limits, etc. | |
| """ | |
| try: | |
| user_data = db.child("users").child(user_id).get().val() | |
| if user_data: | |
| # Update session state with all user data | |
| st.session_state.update(user_data) | |
| # Load TrustBuilder and BrandTonality into session state for display | |
| st.session_state["TrustBuilder"] = user_data.get("TrustBuilder", {}) | |
| st.session_state["BrandTonality"] = user_data.get("BrandTonality", {}) | |
| except Exception as e: | |
| st.info("not loaded ") | |
| def save_content(user_id, content): | |
| """ | |
| Save a TrustBuilder as plain text under the user's TrustBuilders node in Firebase. | |
| """ | |
| try: | |
| # Prepare the TrustBuilder data | |
| trustbuilder_data = { | |
| "content": content | |
| } | |
| # Push to TrustBuilders node under the user's ID | |
| db.child("users").child(user_id).child("TrustBuilders").push(trustbuilder_data) | |
| st.success("TrustBuilder saved successfully!") | |
| except Exception as e: | |
| st.error(f"Error saving TrustBuilder: {e}") | |
| def ai_allocate_trust_bucket(trust_builder_text): | |
| # Implement your AI allocation logic here | |
| return "Stability" | |
| def download_link(content, filename): | |
| """ | |
| Create a download link for content. | |
| """ | |
| b64 = base64.b64encode(content.encode()).decode() | |
| return f'<a href="data:text/plain;base64,{b64}" download="{filename}">Download</a>' | |
| def fetch_documents(): | |
| """ | |
| Fetch all documents for the current user from Firebase and update session state. | |
| """ | |
| user_id = st.session_state["wix_user_id"] | |
| try: | |
| documents = db.child("users").child(user_id).child("KnowledgeBase").get() | |
| st.session_state["documents"] = { | |
| doc.key(): doc.val() for doc in documents.each() | |
| } if documents.each() else {} | |
| except Exception as e: | |
| st.sidebar.error(f"Error fetching documents: {e}") | |
| # Function to delete a document from Firebase | |
| def delete_document(user_id, doc_id): | |
| """ | |
| Deletes a document from Firebase. | |
| """ | |
| try: | |
| db.child("users").child(user_id).child("KnowledgeBase").child(doc_id).remove() | |
| st.success("Document deleted successfully!") | |
| st.rerun() # Refresh the list after deletion | |
| except Exception as e: | |
| st.error(f"Error deleting document: {e}") | |
| def side(): | |
| with st.sidebar: | |
| with st.sidebar.expander("**TrustLogic®**", expanded=False): | |
| st.image("Trust Logic_Wheel_RGB_Standard.png") | |
| st.markdown( | |
| """ | |
| **TrustLogic®** is a proven, scientific method for building trust, showing how our minds process trust. | |
| Remember: | |
| You can’t trust in general – only for specific reasons. | |
| Our mind organizes these reasons into six types of trust: | |
| **Stability**, **Development**, **Relationship**, **Benefit**, **Vision**, and **Competence**. | |
| Together, they form your **trust score**. Every bit more trust counts and can be nudged up in each interaction. | |
| Think of these as the **Six Buckets of Trust®** – the fuller each bucket, the greater the trust. | |
| To build trust, understand what makes you more trustworthy in each **Trust Bucket®** and convey these **Trust Builders®** – because what I don’t know about you, I can’t trust. | |
| **Stability + Development + Relationship + Benefit + Vision + Competence Trust = Your Trust.** | |
| """ | |
| ) | |
| st.markdown("For detailed descriptions, visit [Academy](https://www.trustifier.ai/account/academy)") | |
| st.image("Trust Logic_Wheel_RGB_Standard.png") | |
| st.sidebar.markdown('<hr style="border: 2px solid rgb(255, 153, 0); width: 80%; margin: 20px auto;">', unsafe_allow_html=True) | |
| with st.sidebar.expander("**Trust Buckets® and Trust Builders®**", expanded=False): | |
| st.image("s (3).png") # Adjust width as needed | |
| st.markdown( | |
| "Our minds assess trust through Six Buckets of Trust® and determine their importance and order in a given situation. We then evaluate why we can or can’t trust someone in these Buckets. Trustifier.ai®, trained on 20 years of TrustLogic® application, helps you identify reasons why your audience can trust you in each Bucket and create trust-optimised solutions. It’s copy AI with substance." | |
| ) | |
| st.markdown( | |
| """ | |
| <style> | |
| .stability { color: rgb(7, 55, 99); font-size: 24px; font-weight: bold; } | |
| .development { color: rgb(241, 194, 50); font-size: 24px; font-weight: bold; } | |
| .relationship { color: rgb(204, 0, 0); font-size: 24px; font-weight: bold; } | |
| .benefit { color: rgb(56, 118, 29); font-size: 24px; font-weight: bold; } | |
| .vision { color: rgb(255, 153, 0); font-size: 24px; font-weight: bold; } | |
| .competence { color: rgb(111, 168, 220); font-size: 24px; font-weight: bold; } | |
| </style> | |
| <h3 class="stability">Stability Trust:</h3> | |
| <p>Why can I trust you to have built a strong and stable foundation?</p> | |
| <h5>Examples</h5> | |
| <ul> | |
| <li> | |
| Volkswagen Auto Lease Trust 2023-A's note issuance is an ABS transaction backed by prime automobile lease receivables. This ensures financial reliability for investors. | |
| </li> | |
| <li> | |
| The Group aims to reduce the life-cycle carbon emissions of its vehicles by <strong>30%</strong> compared to 2018, promoting environmental responsibility for customers. | |
| </li> | |
| </ul> | |
| <h3 class="development">Development Trust:</h3> | |
| <p>Why can I trust you to develop well in the future?</p> | |
| <h5>Examples</h5> | |
| <ul> | |
| <li> | |
| In 2023, Volkswagen announced a <strong>€1 billion</strong> investment in a new development and procurement center for electric vehicles in Hefei, China, enhancing the company's commitment to e-mobility. This supports technological advancement for eco-conscious consumers. | |
| </li> | |
| <li> | |
| Volkswagen Group of America launched its first autonomous vehicle test program in Austin, Texas, in July 2023, spearheaded by a dedicated team of engineers. This supports innovation for tech enthusiasts. | |
| </li> | |
| </ul> | |
| <h3 class="relationship">Relationship Trust:</h3> | |
| <p>What appealing relationship qualities can I trust you for?</p> | |
| <h5>Examples</h5> | |
| <ul> | |
| <li> | |
| In March 2023, Volkswagen joined forces with <strong>20 universities</strong> worldwide to advance automotive research, impacting over <strong>5,000 students</strong>. This promotes educational partnerships for academic institutions. | |
| </li> | |
| <li> | |
| Dr. Herbert Diess, CEO of Volkswagen, led initiatives in 2023 to engage <strong>3,000 employees</strong> in community volunteering projects, enhancing corporate social responsibility. This supports community engagement for employees. | |
| </li> | |
| </ul> | |
| <h3 class="benefit">Benefit Trust:</h3> | |
| <p>What benefits can I trust you for?</p> | |
| <h5>Examples</h5> | |
| <ul> | |
| <li> | |
| Volkswagen's commitment to becoming a <strong>net-carbon-neutral</strong> company by 2050 includes using recycled materials to reduce primary raw material needs, supporting sustainability. This promotes environmental responsibility for future generations. | |
| </li> | |
| <li> | |
| The company has reduced water consumption by <strong>24%</strong>, waste by <strong>75%</strong>, and VOC emissions by <strong>68%</strong> per vehicle as of 2023, highlighting its dedication to minimizing environmental impact. This supports eco-friendly manufacturing for industry stakeholders. | |
| </li> | |
| </ul> | |
| <h3 class="vision">Vision Trust:</h3> | |
| <p>What Vision and Values can I trust you for?</p> | |
| <h5>Examples</h5> | |
| <ul> | |
| <li> | |
| The company has committed to investing <strong>€180 billion</strong> between 2023 and 2027 in areas like battery technology, digitalization, and e-mobility, driving forward its vision of sustainable transport. This supports technological advancement for stakeholders. | |
| </li> | |
| <li> | |
| Volkswagen's <strong>"NEW AUTO"</strong> strategy, unveiled in 2023, aims to transform the company into a leading provider of sustainable and software-driven mobility solutions by 2030. This supports future mobility innovation for the automotive industry. | |
| </li> | |
| </ul> | |
| <h3 class="competence">Competence Trust:</h3> | |
| <p>What competencies can I trust you for?</p> | |
| <h5>Examples</h5> | |
| <ul> | |
| <li> | |
| Volkswagen's manufacturing plants in Wolfsburg, Germany, are known for their advanced automation and production techniques, producing over <strong>800,000 vehicles annually</strong>. This supports manufacturing excellence for industry professionals. | |
| </li> | |
| <li> | |
| Volkswagen's design team, led by <strong>Klaus Bischoff</strong>, has received accolades for innovative vehicle designs, enhancing aesthetic appeal and functionality. For instance, the Volkswagen Touareg received the top gold award in the "Passenger Vehicles" category at the German Design Awards. This supports creativity for automotive designers. | |
| </li> | |
| </ul> | |
| """, unsafe_allow_html=True | |
| ) | |
| st.markdown("For detailed descriptions, visit [Academy](https://www.trustifier.ai/account/academy)") | |
| st.image("s (3).png") # Adjust width as needed | |
| st.sidebar.markdown('<hr style="border: 2px solid rgb(255, 153, 0); width: 80%; margin: 20px auto;">', unsafe_allow_html=True) | |
| st.header("TrustVault®") | |
| st.markdown("In the TrustVault you can save your preferred trust equity Trust Builders®, great outputs, brand and segment info for easy use.") | |
| st.sidebar.markdown(""" | |
| <style> | |
| .scrollable-container { | |
| max-height: 200px; | |
| overflow-y: auto; | |
| border: 1px solid gray; | |
| padding: 10px; | |
| border-radius: 5px; | |
| background-color: #f9f9f9; | |
| margin-bottom: 10px; | |
| } | |
| .button-container { | |
| display: flex; | |
| justify-content: space-between; | |
| gap: 10px; | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| # Fetch documents from Firebase | |
| if "documents" not in st.session_state: | |
| try: | |
| docs = db.child("users").child(st.session_state["wix_user_id"]).child("KnowledgeBase").get().val() | |
| st.session_state["documents"] = docs if docs else {} | |
| except Exception as e: | |
| st.sidebar.error(f"Error fetching documents: {e}") | |
| st.session_state["documents"] = {} | |
| def update_saved_docs_content(): | |
| return "\n\n---\n\n".join( | |
| [ | |
| f"**{doc_data.get('name', f'Document {doc_id[:8]}')}**\n{doc_data.get('content', 'No content available')}" | |
| for doc_id, doc_data in st.session_state["documents"].items() | |
| ] | |
| ) if st.session_state["documents"] else "Save documents like your brand tonality, key phrases, or segments here and they will show here." | |
| saved_docs_content = update_saved_docs_content() | |
| st.text_area( | |
| label="", | |
| value=saved_docs_content, | |
| height=150, | |
| key="saved_documents_text_area", | |
| disabled=True | |
| ) | |
| # File uploader | |
| uploaded_files = st.file_uploader( | |
| "", | |
| type=["pdf", "docx", "txt"], | |
| accept_multiple_files=True, | |
| key="file_uploader" | |
| ) | |
| if uploaded_files: | |
| for uploaded_file in uploaded_files: | |
| try: | |
| upload_to_firebase(st.session_state["wix_user_id"], uploaded_file) | |
| except Exception as e: | |
| st.sidebar.error(f"Error processing file '{uploaded_file.name}': {e}") | |
| # Display and delete functionality for documents | |
| if st.session_state.get("documents"): | |
| doc_ids = list(st.session_state["documents"].keys()) | |
| doc_options = ["None (use only main knowledge base)"] + doc_ids | |
| selected_options = st.multiselect( | |
| "", | |
| options=doc_options, | |
| default="None (use only main knowledge base)", | |
| format_func=lambda x: st.session_state["documents"][x].get("name", f"Document {x}") if x != "None (use only main knowledge base)" else x, | |
| key="select_docs" | |
| ) | |
| selected_doc_ids = [doc_id for doc_id in selected_options if doc_id != "None (use only main knowledge base)"] | |
| st.session_state['selected_doc_ids'] = selected_doc_ids | |
| if selected_doc_ids: | |
| selected_doc_names = [st.session_state['documents'][doc_id]['name'] for doc_id in selected_doc_ids] | |
| st.info(f"Selected Documents: {', '.join(selected_doc_names)}") | |
| else: | |
| st.sidebar.info("Using only the main knowledge base.") | |
| else: | |
| selected_doc_ids = [] | |
| # Button to delete the selected documents | |
| if selected_doc_ids: | |
| if st.button("Delete", key="delete_button"): | |
| try: | |
| for doc_id in selected_doc_ids: | |
| # Remove the document from Firebase | |
| db.child("users").child(st.session_state["wix_user_id"]).child("KnowledgeBase").child(doc_id).remove() | |
| # Remove from session state | |
| st.session_state["vector_store"].pop(doc_id, None) | |
| st.session_state["documents"].pop(doc_id, None) | |
| st.success("Selected documents deleted successfully!") | |
| st.rerun() | |
| except Exception as e: | |
| st.error(f"Error deleting documents: {e}") | |
| st.sidebar.markdown("</div>", unsafe_allow_html=True) | |
| trust_buckets = ["Any","Stability", "Development", "Relationship", "Benefit", "Vision", "Competence"] | |
| st.markdown(""" | |
| <style> | |
| .info-icon { | |
| display: inline-block; | |
| margin-left: 8px; | |
| color: #007BFF; | |
| cursor: pointer; | |
| position: relative; | |
| } | |
| .tooltip { | |
| visibility: hidden; | |
| width: 250px; | |
| background-color: #555; | |
| color: #fff; | |
| text-align: center; | |
| border-radius: 5px; | |
| padding: 5px; | |
| position: absolute; | |
| z-index: 1; | |
| bottom: 125%; /* Position above the icon */ | |
| left: 50%; | |
| margin-left: -125px; /* Center the tooltip */ | |
| opacity: 0; | |
| transition: opacity 0.3s; | |
| } | |
| .info-icon:hover .tooltip { | |
| visibility: visible; | |
| opacity: 1; | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| # Add the header with the info icon and hover effect | |
| st.markdown(""" | |
| <div style="display: flex; align-items: center;"> | |
| <h3>Show My TrustBuilders®</h3> | |
| <div class="info-icon"> | |
| ⓘ | |
| <span class="tooltip">You can ask AI to find your TrustBuilders® also by prompting "show my saved trustbuilders".</span> | |
| </div> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| search_query = st.text_input("Search by keyword", key="search_query") | |
| st.write("or") | |
| search_query1 = st.text_input("Search by Brand/Product/Person", key="search_query1") | |
| # Dropdown for selecting a trust bucket | |
| selected_bucket = st.selectbox("Select Trust Bucket", trust_buckets, key="selected_bucket") | |
| # Button to show results | |
| if st.button("Show TrustBuilders", key="show_trustbuilders"): | |
| # Fetch trustbuilders | |
| trustbuilders = fetch_trustbuilders(st.session_state.get("wix_user_id")) | |
| # Initialize variable for a match | |
| matching_trustbuilders = [] | |
| # Filter trustbuilders based on the criteria | |
| for tb in trustbuilders: | |
| # Split bucket and text | |
| bucket, text = tb.split(": ", 1) if ": " in tb else ("", tb) | |
| # Check if bucket matches or "Any" is selected | |
| bucket_matches = selected_bucket == "Any" or bucket == selected_bucket | |
| # Match keyword or brand/product/person search | |
| keyword_match = search_query.lower() in text.lower() if search_query else False | |
| additional_match = search_query1.lower() in text.lower() if search_query1 else False | |
| # Append if all conditions are met | |
| if bucket_matches and (keyword_match or additional_match): | |
| matching_trustbuilders.append(tb) | |
| # Display the first matching trustbuilder | |
| if matching_trustbuilders: | |
| st.write("### Result:") | |
| # Join the matching trustbuilders into a bullet list | |
| st.markdown("\n".join([f"- {tb}" for tb in matching_trustbuilders])) | |
| else: | |
| st.write("No TrustBuilders found matching the criteria.") | |
| # UI for saving TrustBuilders | |
| st.subheader("Save TrustBuilders®") | |
| brand_save = st.text_input("Brand/Product/Person", key="brand_input_save") | |
| trust_builder_text = st.text_area("Type/paste Trust Builder®", key="trust_builder_text") | |
| trust_buckets = ["Stability", "Development", "Relationship", "Benefit", "Vision", "Competence"] | |
| selected_save_bucket = st.selectbox("Allocate to®", trust_buckets, key="save_bucket") | |
| col1, col2 = st.columns([1, 1]) # Adjust column widths as needed | |
| with col1: | |
| if st.button("Allocate", key="save_trustbuilder"): | |
| if trust_builder_text.strip() and selected_save_bucket: | |
| content_to_save = f"{selected_save_bucket}: Brand: {brand_save.strip()} | {trust_builder_text.strip()}" | |
| save_content(st.session_state.get("wix_user_id"), content_to_save) | |
| else: | |
| st.warning("Please fill all fields") | |
| with col2: | |
| tooltip_css = """ | |
| <style> | |
| /* Tooltip container styling */ | |
| .tooltip-container { | |
| position: relative; | |
| display: inline-block; | |
| vertical-align: top; | |
| width: 100%; | |
| margin-top: -15px; /* Aligns with st.button */ | |
| } | |
| /* Tooltip text styling */ | |
| .tooltip-container .tooltiptext { | |
| visibility: hidden; | |
| width: 300px; /* Fixed width for better readability */ | |
| max-width: 90%; /* Ensure tooltip fits within sidebar */ | |
| background-color: #f9f9f9; | |
| color: #333; | |
| text-align: left; | |
| border-radius: 8px; | |
| padding: 10px; | |
| box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1); | |
| position: absolute; | |
| z-index: 1000; /* Ensure tooltip is above other elements */ | |
| top: calc(100% + 10px); /* Position tooltip below the button with spacing */ | |
| left: 50%; /* Center horizontally */ | |
| transform: translateX(-50%); | |
| opacity: 0; | |
| transition: opacity 0.3s ease-in-out; | |
| } | |
| /* Show tooltip on hover */ | |
| .tooltip-container:hover .tooltiptext { | |
| visibility: visible; | |
| opacity: 1; | |
| } | |
| /* Button styling */ | |
| .tooltip-container button { | |
| background-color: rgb(82, 129, 134); | |
| color: white; | |
| border: none; | |
| padding: 8px 16px; | |
| font-size: 14px; | |
| border-radius: 5px; | |
| cursor: pointer; | |
| box-shadow: 0px 4px 8px rgba(0,0,0,0.2); | |
| font-family: Arial, sans-serif; | |
| } | |
| /* Hover effect for button */ | |
| .tooltip-container button:hover { | |
| background-color: rgb(70, 115, 119); | |
| } | |
| </style> | |
| """ | |
| # Inject CSS | |
| st.markdown(tooltip_css, unsafe_allow_html=True) | |
| # Tooltip Button | |
| st.markdown(""" | |
| <div class="tooltip-container"> | |
| <button>LetAI Allocate</button> | |
| <span class="tooltiptext"> | |
| <b>Here’s how you can save your TrustBuilder®:</b><br><br> | |
| 1. Type your TrustBuilder® in the chat.<br> | |
| 2. If unsure of the TrustBucket®, ask the AI:<br> | |
| <i>"Hey, which TrustBucket does this TrustBuilder® belong to?"</i><br><br> | |
| 3. Save it using the following format:<br> | |
| <code>Save this as a TrustBuilder. [BucketName]. [TrustBuilder Text]</code><br><br> | |
| Example:<br> | |
| <code>Save this as a TrustBuilder. Stability. We focus on keeping and nurturing our team.</code> | |
| </span> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| side() | |
| if st.session_state.get("wix_user_id") and "faiss_db" not in st.session_state: | |
| refresh_faiss_index() | |
| def update_message_counter(): | |
| remaining_messages = st.session_state["message_limit"] - st.session_state["used_messages"] | |
| message_counter_placeholder = st.sidebar.empty() | |
| message_counter_placeholder.markdown(f" Message left : unlimited \n\n Unlimited chats for a limited time") | |
| update_message_counter() | |
| # Define search functions | |
| def search_knowledge_base(query, k=3): | |
| """Optimized FAISS search for main knowledge base and user-specific knowledge base.""" | |
| results = [] | |
| # Search in the main FAISS index | |
| if "main_faiss_db" in st.session_state and st.session_state["main_faiss_db"] is not None: | |
| main_results = st.session_state["main_faiss_db"].similarity_search_with_score(query, k=5) # Fetch extra results for better ranking | |
| results.extend(main_results) | |
| # Search in the selected document's FAISS index | |
| if "faiss_db" in st.session_state and st.session_state["faiss_db"] is not None: | |
| user_results = st.session_state["faiss_db"].similarity_search_with_score(query, k=5) # Fetch extra results for better ranking | |
| results.extend(user_results) | |
| # Sort results by similarity score (higher score = more relevant) | |
| sorted_results = sorted(results, key=lambda x: x[1], reverse=True) | |
| # Return only the top `k` most relevant results | |
| return [result[0] for result in sorted_results[:k]] | |
| def google_search(query): | |
| """ | |
| Performs a Google search using the Serper API and retrieves search result snippets. | |
| Args: | |
| query (str): The search query to be used for the Google search. | |
| Returns: | |
| list: A list of valid snippets from the search results. Returns an error message if an error occurs. | |
| """ | |
| # API Configuration | |
| url = "https://google.serper.dev/search" | |
| api_key = "07b4113c2730711b568623b13f7c88078bab9c78" | |
| headers = { | |
| "X-API-KEY": api_key, | |
| "Content-Type": "application/json", | |
| } | |
| # Payload for the query | |
| payload = json.dumps({"q": query}) | |
| try: | |
| # Perform the API request | |
| response = requests.post(url, headers=headers, data=payload, timeout=10) # 10-second timeout | |
| response.raise_for_status() # Raise HTTPError for bad responses (4xx, 5xx) | |
| # Parse the response JSON | |
| results = response.json() | |
| # Extract and validate snippets | |
| snippets = [ | |
| result["snippet"] for result in results.get("organic", []) | |
| if result.get("snippet") # Ensure snippet exists | |
| ] | |
| # Return valid snippets or a fallback message | |
| return snippets if snippets else ["No valid data found in results"] | |
| except requests.exceptions.HTTPError as http_err: | |
| print(f"HTTP error occurred: {http_err}") | |
| return ["HTTP error occurred during Google search"] | |
| except requests.exceptions.Timeout: | |
| print("Request timed out") | |
| return ["Request timed out"] | |
| except requests.exceptions.RequestException as req_err: | |
| print(f"Request error occurred: {req_err}") | |
| return ["Request error occurred during Google search"] | |
| except Exception as e: | |
| print(f"General Error: {e}") | |
| return ["Error occurred during Google search"] | |
| # RAG response function | |
| def rag_response(query, selected_doc_ids=None, selected_analyser_ids=None): | |
| """ | |
| Handle queries by searching the main knowledge base, selected documents, and analyzer files. | |
| """ | |
| try: | |
| results = [] | |
| # Search FAISS database (main knowledge base) | |
| if "faiss_db" in st.session_state: | |
| retrieved_docs = search_knowledge_base(query,k=3) | |
| results.extend(retrieved_docs) | |
| # If selected_doc_ids is None, try to get it from session state | |
| if selected_doc_ids is None: | |
| selected_doc_ids = st.session_state.get("selected_doc_ids", []) | |
| # If selected_analyser_ids is None, try to get it from session state | |
| if selected_analyser_ids is None: | |
| selected_analyser_ids = st.session_state.get("selected_analyser_file_ids", []) | |
| # Search vector stores of the selected documents | |
| if selected_doc_ids: | |
| for doc_id in selected_doc_ids: | |
| vector_store = st.session_state.get("vector_store", {}).get(doc_id) | |
| if vector_store is None: | |
| st.warning(f"Vector store for document '{doc_id}' not found.") | |
| continue # Skip this iteration if vector store is missing | |
| vector_store_results = vector_store.similarity_search(query, k=5) | |
| results.extend(vector_store_results) | |
| # Search content of analyzer files (e.g., XLSX content) | |
| for analyser_id in selected_analyser_ids: | |
| analyser_data = st.session_state.get("analyser_files", {}).get(analyser_id, {}) | |
| if "content" in analyser_data: | |
| # Perform search on analyzer file content | |
| analyser_results = search_excel_content(analyser_data["content"], query) | |
| results.extend(analyser_results) | |
| else: | |
| st.warning(f"No content found in Analyzer file '{analyser_id}'.") | |
| # Combine results into a single context | |
| context = "\n".join([doc.page_content if isinstance(doc, Document) else str(doc) for doc in results]) | |
| if not context.strip(): | |
| return "No relevant data found in the knowledge base." | |
| # Generate AI response with the retrieved context | |
| prompt = f""" | |
| Context: | |
| {context} | |
| Rules: | |
| 1. Use only the provided context to generate your answer. | |
| 2. Match headings and content exactly as they appear in the knowledge base. Do not add, modify, or generalize content. | |
| 3. Maintain clarity and accuracy. | |
| 4. Follow instructions strictly. | |
| Question: | |
| {query} | |
| Answer: | |
| """ | |
| llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.4, api_key=openai_api_key) | |
| response = llm.invoke(prompt) | |
| return response.content.strip() | |
| except Exception as e: | |
| logger.error(f"Error generating RAG response: {e}") | |
| return "An error occurred during the RAG response generation process." | |
| # Define tools | |
| def knowledge_base_tool(query: str): | |
| """Query the knowledge base and retrieve a response.""" | |
| return rag_response(query) | |
| def google_search_tool(query: str): | |
| """Perform a Google search using the SERPER API.""" | |
| return google_search(query) | |
| tavily_tool = TavilySearchResults( | |
| max_results=12, | |
| search_depth="advanced", | |
| days=1, | |
| include_answer=True, | |
| include_raw_content=False, | |
| query_context=( | |
| "Extract details from the internet related to the Brand. Give me multiple different source links and latest please 2024 onwards" | |
| ), | |
| include_domains=[ | |
| ], | |
| exclude_domains=[ | |
| 'example.com', | |
| 'https://www.trustlogic.us', | |
| 'https://huggingface.co', | |
| 'https://huggingface.co/spaces/trustlogic/FH-AI/commit/ef6fd56353ff4d7308bf7ed4e9c27d9aec43126b' | |
| ], | |
| ) | |
| # Compile all tool functions into a list | |
| tools = [ | |
| knowledge_base_tool, # Tool for querying the knowledge base and retrieving responses | |
| tavily_tool, | |
| # google_search_tool, # Tool for performing a Google search and retrieving search result snippets | |
| ] | |
| prompt_message = f""" | |
| **You are an expert multilingual Only Active language copywriter specializing in creating highly fluid, compelling, and interconnected marketing copy that seamlessly integrates Trust Builders into various content formats for any organization. Your goal is to craft concise , engaging material based on the knowledgebase, adhering to the following guidelines:** | |
| - Write in **active voice** using **first-person perspective (“we”)**, avoiding third-person. | |
| - Ensure **seamless flow** with logical transitions between paragraphs, maintaining relevance and consistency. | |
| - Contextually integrate trust-building elements creatively. Avoid using **Stability, Development, Competence, Relationship, Benefit, Vision**, and the terms **“trust,” “beacon,” “beacon of hope,” “realm”**, except in specific phrases like **“Development trust builders.”** | |
| - Focus on clarity, avoiding jargon or repetition while emphasizing impact on the audience. | |
| ### Key Requirements | |
| **Adhere to Uploaded Document's Style**: | |
| - Match the uploaded document's tone, structure, and style exactly. | |
| - Use the same level of language complexity and formality. | |
| - If the uploaded document includes headings, subheadings, or specific formatting, replicate them. If none exist, avoid including headings. | |
| ### MANDATORY Elements | |
| - **Avoid Prohibited Terms**: | |
| - Do **not** mention "trust," "trust buckets," or any category names like "Development," "Stability," "Competence," "Relationship," "Vision" in the copy. | |
| - Use these terms for searching and headings but **not in the content or any copy**. | |
| - **Consistency**: Maintain a uniform format across all content types. | |
| - Do not generate unverified or placeholder claims. | |
| - **Formatting**: Ensure formatting is clean and professional, with **no HTML tags**. | |
| - **List of TrustBuilders Used**: | |
| - Include relevant TrustBuilders® in every response. | |
| - Provide embedded, clickable source links for each TrustBuilder®. | |
| - **Heuristics and Creative Techniques**: | |
| - Always include heuristics and creative techniques at the end of the response. | |
| - Use the following format under separate headings: | |
| - **Heuristics**: List relevant examples (e.g., social proof, authority, commitment). | |
| - **Creative Techniques**: List relevant marketing techniques (e.g., storytelling, visual metaphors). | |
| *Top Trustbuckets and Builders: | |
| - Use the following format to display all buckets and display statements for prospects and customers from knowledgebase: | |
| Top-scoring statements | |
| -Give in bullet points under each bucket-name with percentage. | |
| **Bucket Name** | |
| 1- TrustBuilder® Statement 1 [Percentage] | |
| 2- TrustBuilder® Statement 2 [Percentage] | |
| 3- TrustBuilder® Statement 3 [Percentage] | |
| ### MANDATORY VERIFICATION CHECKLIST: | |
| Before submitting **any content**, ensure that each piece includes: | |
| 1. **Specific Details**: | |
| - **At least 3 specific dollar amounts** with exact figures (e.g., "$127.5 million"). | |
| - **Minimum 2 full dates** with day/month/year (e.g., "March 15, 2023"). | |
| - **At least 3 specific quantities** of people/items (e.g., "12,457 beneficiaries"). | |
| - **Minimum 2 full names with titles** | |
| - **At least 2 complete program names with years** (e.g., "Operation Healthy Future 2024-2025"). | |
| - **At least 1 specific award**with year and organization (e.g., "2023 UN Global Health Excellence Award"). | |
| - **Minimum 2 measurable outcomes with percentages** (e.g., "47% reduction in malnutrition"). | |
| 2. **Audience Relevance**: | |
| - **Each point must be followed by**: | |
| - "This [specific benefit] for [specific audience]" | |
| - **Example**: "This reduces wait times by 47% for patients seeking emergency care." | |
| *SOURCE LINK* | |
| 1. **Each source link must**: | |
| -Be Latest, factual and verifiable not page not found links please. | |
| 2. Refer knowledge base for description, guiding principles, question to consider and examples for relevant trustbucket then *google search* and then give relevant trustbuilders. | |
| ##SPECIFICITY ENFORCEMENT | |
| Replace vague phrases with specific details: | |
| - ❌ "many" → ✅ exact number. | |
| - ❌ "millions" → ✅ "$127.5 million". | |
| - ❌ "recently" → ✅ "March 15, 2023". | |
| - ❌ "global presence" → ✅ "offices in 127 cities across 45 countries". | |
| - ❌ "industry leader" → ✅ "ranked #1 in customer satisfaction by J.D. Power in 2023". | |
| - ❌ "significant impact" → ✅ "47% reduction in processing time". | |
| ### CONTENT TYPES AND FORMATS | |
| #### 1. Report/Article/writeup/blog | |
| - **Introduction**: Start with "Here is a draft of your [Annual Report/Article/writeup]. Feel free to suggest further refinements." | |
| - **Structure**: | |
| - **Headlines **: .Headline should be like this in active language *without mentioning prohibited terms and -ing **. | |
| - **Content**: | |
| - **Donot give any source link in contents** | |
| - **Perspective**: Write as if you are part of the organization (using "we"), emphasizing togetherness and collective effort. | |
| - **Integration**: Interweave various trust-builder fluidly, focusing on specifics like names, numbers (dollar amounts and years), programs, strategies, places, awards, and actions, **without mentioning prohibited terms**. | |
| - **Avoid Flowery Language**: Ensure content is clear and factual. | |
| - Use an **active, engaging, and direct tone**. Eg:"World Vision partners with [organizations] to drive progress." | |
| #### 2. Social Media Posts | |
| - **Introduction Line**: Start with "Here is a draft of your social media post. Feel free to suggest further refinements." | |
| - **Content**: | |
| - Ensure the post is **concise, impactful**, and designed to engage the audience. | |
| - **Avoid prohibited terms or flowery language**. | |
| - **Include specific names, numbers, programs, strategies, places, awards, and actions** to enhance credibility. | |
| - Focus on **clear messaging**. | |
| - **Additional Requirements**: | |
| - Do **not** mention prohibited terms in hashtags or post copy. | |
| - Ensure **source links are not included** in the post text. | |
| - **Sub-Headings (After Summary) **: | |
| 1. **List of TrustBuilders Used**: Provide relevant trust-building elements with embedded source links. | |
| 2. **Heuristics and Creative Techniques**: | |
| - List them in footnote-style tiny small heading. | |
| - Select and name only **3-5 relevant heuristics** with tight bullet points. | |
| - Name only the relevant marketing creative techniques, with no additional details. | |
| - **Word Count**: Follow any specified word count. | |
| - **Important Notes**: | |
| - **Strictly search and provide accurate source links always**. | |
| #### 3. Sales Conversations or Ad Copy | |
| - **Introduction Line**: Start with "Here is a draft of your [Sales Conversation/Ad Copy]. Feel free to suggest further refinements." | |
| - **Content**: | |
| - Include **persuasive elements** with integrated trust-building elements, interconnecting them fluidly **without mentioning prohibited terms**. | |
| - **Avoid flowery language** and focus on factual, specific information such as names, numbers, and actions. | |
| - **Sub-Headings(After Summary) **: | |
| 1. **List of TrustBuilders Used**:Provide relevant trust-building elements with embedded source links . | |
| 2. **Heuristics and Creative Techniques**: | |
| - List them in footnote-style tiny small heading. | |
| - Select and name only **3-5 relevant heuristics** with tight bullet points. | |
| - Name only the relevant marketing creative techniques, with no additional details. | |
| - **Important Notes**: | |
| - Strictly search and provide accurate source links always. | |
| #### 4. Emails, Direct Marketing Letters** | |
| - **Introduction Line**: Start with "Here is a draft of your [Email/Newsletter/Letter,Blog]. Feel free to suggest further refinements." | |
| - **Structure**: | |
| - **Headlines**: WRITE CREATIVE ACTIVE LANGUAGE HEADLINE THAT SUMMARISES THE POINTS YOU MAKE.Headline should be like this in activae language eg.we empower instead **without mentioning prohibited terms**. | |
| - **Content**: | |
| - Use **headings** with all content paragraphs to structure the article.** Donot give any source link in contents** | |
| - **Perspective**: Write as if you are part of the organization (using "we"), emphasizing togetherness and collective effort. | |
| - **Integration**: Interweave various trust-builder fluidly, focusing on specifics like names, numbers (dollar amounts and years), programs, strategies, places, awards, and actions, **without mentioning prohibited terms**. | |
| - **Avoid Flowery Language**: Ensure content is clear and factual. | |
| - Use an **active, engaging, and direct tone**. Eg:"World Vision partners with [organizations] to drive progress." | |
| - **Sub-Headings(After Summary) **: | |
| 1. **List of TrustBuilders Used**: Provide relevant trust-building elements followed with embedded source links. | |
| 2. **Heuristics and Creative Techniques**: | |
| -List them in a footnote-style small heading. | |
| -Use the following structure: | |
| -Heuristics: examples (e.g., social proof, authority, commitment). | |
| -Creative Techniques: examples (list only relevant marketing techniques without additional details). | |
| -Limit to 3-5 items in each category. | |
| Note: When including heuristics and creative techniques, use the structure “Heuristics: examples” and “Creative Techniques: examples” with no extra details. | |
| - **Word Count**: Follow any specified word count for the main body. Do not count sub-heading sections in the word count limit. | |
| ### 5.Trust-Based Queries:** | |
| -Be over specific with numbers,names,dollars, programs ,awards and action. | |
| - When a query seeks a specific number of trust builders (e.g., "5 trust builders"), the AI should: | |
| - Randomly pick the requested number of trust buckets from the six available: Development Trust, Competence Trust, Stability Trust, Relationship Trust, Benefit Trust, and Vision Trust. | |
| - For each selected bucket, find 15 TrustBuilders® points be over specific with numbers,names,dollars, programs ,awards and action. | |
| - Categorize these points into Organization, People, and Offers/Services (with 5 points for each category). | |
| - **Each point must be followed by**: | |
| - "This [specific benefit] for [specific audience]" | |
| - **Example**: "This reduces wait times by 47% for patients seeking emergency care." | |
| -For each selected bucket, find 15 TrustBuilders® points. | |
| -**Categorization:** Categorize these points into three sections with **specific details**: | |
| - **[Category Name]** | |
| - **Organization** (5 points) | |
| - **People** (5 points) | |
| - **Offers/Services** (5 points) | |
| - **[Next Category Name]** | |
| - **Organization** (5 points) | |
| - **People** (5 points) | |
| - **Offers/Services** (5 points) | |
| - **Important Specificity:** Always include **names**, **numbers** (e.g., $ amounts and years), **programs**, **strategies**, **places**, **awards**, and **actions** by searching on google to add credibility and depth to the content. Ensure that trust-building points are detailed and specific. | |
| - **For Specific Categories:** | |
| - When a query asks for a specific category (e.g., "Development trust builders"), find 15 trust-building points that are specific with relevant names, numbers like $ amounts and years, programs, strategies, places, awards, and actions specifically for that category. | |
| - Categorize these points into Organization, People, and Offers/Services (with 5 points for each category). | |
| - **Format:** | |
| - **Introduction Line:** Start with "Here are TrustBuilders® for [Selected Categories] at [Organization Name]. Let me know if you want to refine the results or find more." | |
| - **Categories:** | |
| - **Organization:** | |
| - [Trust-Building Point 1] - [Source](#) | |
| - [Trust-Building Point 2] - [Source](#) | |
| - [Trust-Building Point 3] - [Source](#) | |
| - [Trust-Building Point 4] - [Source](#) | |
| - [Trust-Building Point 5] - [Source](#) | |
| - **People:** | |
| - [Trust-Building Point 6] - [Source](#) | |
| - [Trust-Building Point 7] - [Source](#) | |
| - [Trust-Building Point 8] - [Source](#) | |
| - [Trust-Building Point 9] - [Source](#) | |
| - [Trust-Building Point 10] - [Source](#) | |
| - **Offers/Services:** | |
| - [Trust-Building Point 11] - [Source](#) | |
| - [Trust-Building Point 12] - [Source](#) | |
| - [Trust-Building Point 13] - [Source](#) | |
| - [Trust-Building Point 14] - [Source](#) | |
| - [Trust-Building Point 15] - [Source](#) | |
| - Ensure each selected category contains 15 trust-building points, categorized as specified. | |
| - Provide bullet points under each section with relevant accurate source link. | |
| **Important Notes:** | |
| - Strictly search and provide accurate source links always with each point. | |
| - **No Subheadings or Labels:** Under each main category, list the trust-building points directly as bullet points or numbered lists **without any additional subheadings, labels, descriptors, phrases, or words before the points**. | |
| - **Avoid Flowery Language:** Do not use any flowery or exaggerated language. | |
| - **Do Not Include:** | |
| - Heuristics and Creative Techniques** in Trust-Based Queries. | |
| - Subheadings or mini-titles before each point. | |
| - Labels or descriptors like "Strategic Partnerships:", "Global Reach:", etc. | |
| - Colons, dashes, or any formatting that separates a label from the point. | |
| - **Do Include:** | |
| - The full sentence of the trust-building point starting directly after the bullet, with specific details. | |
| - **Do Not Include the Prohibited Terms:** Do not mention the prohibited terms anywhere, **even when asked**. | |
| -*Donot provide list of trustbuilders used and heuristics here. That is for copy applications not here. | |
| - **Example of Correct Format**: | |
| **Organization** | |
| - In **20XX**, World Vision invested **$150 million** in sustainable agriculture programs across **35 countries**, impacting over **2 million** farmers.This improves food security for vulnerable communities.- [Source](#) | |
| ### 6. LinkedIn Profile | |
| - If requested, generate a LinkedIn profile in a professional manner. | |
| - **Avoid prohibited terms** and **flowery language**. | |
| ### General Queries | |
| - Do not use the knowledge base for non-trust content. | |
| - Always clarify the audience impact and ensure all information is based on verified sources. | |
| -Refer knowledgebase when asked about trustifier or TrustLogic. Trustlogic means Trustlogic.info | |
| -mext means mext consulting(https://www.mextconsulting.com/) by stefan grafe and also trustlogic.info. | |
| "MOST IMPORTANT RULE. IN EVERY PARAGRAPH Strengthen the connections between sections to ensure smoother flow and SHOULD BE DEEPLY INTERCONNECTED WITH EACH OTHER TO CREATE A SEAMLESS FLOW, MAKING THE CONTENT READ LIKE A SINGLE CONTENT RATHER THAN DISJOINTED PARAGRAPHS OR INDEPENDENT BLOG SECTIONS. EACH SECTION MUST LOGICALLY TRANSITION INTO THE NEXT, ENSURING THAT THE TOPIC REMAINS CONSISTENT AND RELEVANT THROUGHOUT. BY MAINTAINING A COHESIVE STRUCTURE, THE ARTICLE WILL ENGAGE READERS MORE EFFECTIVELY, HOLDING THEIR ATTENTION AND CONVEYING THE INTENDED MESSAGE WITH CLARITY AND IMPACT." | |
| """ | |
| prompt_template = ChatPromptTemplate.from_messages([ | |
| ("system", prompt_message), | |
| MessagesPlaceholder(variable_name="chat_history"), | |
| ("user", "{input}"), | |
| MessagesPlaceholder(variable_name="agent_scratchpad"), | |
| ]) | |
| # Create Langchain Agent | |
| llm = ChatOpenAI( | |
| model="gpt-4o", | |
| temperature=0.5, # Balanced creativity and adherence | |
| #top_p=0.85, # Focused outputs | |
| # Moderate novelty to maintain adherence | |
| ) | |
| llm_with_tools = llm.bind_tools(tools) | |
| # Define the agent pipeline | |
| agent = ( | |
| { | |
| "input": lambda x: x["input"], | |
| "agent_scratchpad": lambda x: format_to_openai_tool_messages(x["intermediate_steps"]), | |
| "chat_history": lambda x: x["chat_history"], | |
| } | |
| | prompt_template | |
| | llm_with_tools | |
| | OpenAIToolsAgentOutputParser() | |
| ) | |
| # Instantiate an AgentExecutor | |
| agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) | |
| # Streamlit app | |
| # Display chat history | |
| for message in st.session_state.chat_history: | |
| with st.chat_message(message["role"]): | |
| st.markdown(message["content"]) | |
| # Chat input | |
| if not st.session_state.get("chat_started", False): | |
| st.markdown(""" | |
| <script> | |
| document.addEventListener('DOMContentLoaded', (event) => { | |
| const svgs = document.querySelectorAll('svg'); | |
| svgs.forEach(svg => { | |
| if (svg.getAttribute('xmlns') === 'http://www.w3.org/2000/svg' && svg.getAttribute('width') === '18' && svg.getAttribute('height') === '18') { | |
| svg.style.display = 'none'; | |
| } | |
| }); | |
| }); | |
| </script> | |
| <style> | |
| /* Hide all <a> elements inside elements with block-container and st-emotion-cache-1eo1tir ea3mdgi5 classes */ | |
| .block-container.st-emotion-cache-1eo1tir.ea3mdgi5 a { | |
| display: none !important; | |
| } | |
| /* Ensure links in the sidebar are visible and underlined */ | |
| .stSidebar a { | |
| display: inline !important; | |
| text-decoration: underline !important; | |
| color: inherit !important; | |
| } | |
| /* Additional styles */ | |
| .section-container { | |
| display: flex; | |
| justify-content: center; | |
| align-items: stretch; | |
| flex-wrap: wrap; | |
| gap: 4px; | |
| } | |
| .section { | |
| flex: 1; | |
| min-width: 150px; | |
| max-width: 90px; | |
| min-height: 150px; | |
| border: 1px solid #afafaf; | |
| border-radius: 10px; | |
| padding: 5px; | |
| background-color: transparent; | |
| margin: 3px; | |
| text-align: center; | |
| box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); | |
| box-sizing: border-box; | |
| font-size: 12px; | |
| transition: background-color 0.3s ease; | |
| } | |
| .section h2 { | |
| color: #afafaf; | |
| font-size: 14px; | |
| margin-bottom: 8px; | |
| border-bottom: 1px solid #afafaf; | |
| padding-bottom: 4px; | |
| text-align: center; /* Center headings */ | |
| } | |
| .section p { | |
| color: #afafaf; | |
| font-size: 11px; | |
| margin: 5px 0; | |
| line-height: 1.4; | |
| } | |
| @media (max-width: 100px) { | |
| .section { | |
| min-width: 90%; | |
| max-width: 90%; | |
| } | |
| } | |
| </style> | |
| <h1 style="text-align: center; background: #528186; -webkit-background-clip: text; color: transparent;">How can I help you today?</h1> | |
| <div class="section-container"> | |
| <div class="section"> | |
| <h2>Find</h2> | |
| <p>Discover all your great TrustBuilders®. <br> Example: Find Development Trust Builders® for World Vision | |
| </div> | |
| <div class="section"> | |
| <h2>Create</h2> | |
| <p>Generate trust-optimised solutions : <br>Example: Find World Vision development TrustBuilders®. Then use them to write a 200-word annual report article. Enthusiastic tone.</p> | |
| </div> | |
| <div class="section"> | |
| <h2>Trust-optimise</h2> | |
| <p>Paste your LinkedIn profile, EDM or blog and ask Trustifier.ai® to improve it using specific Trust Buckets® and add your specific TrustBuilders® as examples.</p> | |
| </div> | |
| </div> | |
| <div style="height: 50px;"></div> <!-- Adds a gap of 50px after the section containers --> | |
| """, unsafe_allow_html=True) | |
| hide_specific_warning = """ | |
| <script> | |
| document.addEventListener('DOMContentLoaded', function() { | |
| const alerts = window.parent.document.querySelectorAll('div[data-testid="stAlert"]'); | |
| alerts.forEach(function(alert) { | |
| if (alert.innerText.includes('Please replace st.experimental_get_query_params with st.query_params')) { | |
| alert.style.display = 'none'; // Hide the warning | |
| alert.style.visibility = 'hidden'; // Make it invisible | |
| alert.style.height = '0px'; // Set height to zero to remove space | |
| alert.style.margin = '0px'; // Set margin to zero | |
| alert.style.padding = '0px'; // Set padding to zero | |
| } | |
| }); | |
| }); | |
| </script> | |
| """ | |
| # Embed the JavaScript in your Streamlit app | |
| components.html(hide_specific_warning, height=0, scrolling=False) | |
| query_params = st.experimental_get_query_params() | |
| wix_user_id = query_params.get('wix_user_id', [None])[0] | |
| email = query_params.get('email', [None])[0] | |
| # Session state to track user login and message usage | |
| if "wix_user_id" not in st.session_state: | |
| st.session_state["wix_user_id"] = wix_user_id | |
| if "email" not in st.session_state: | |
| st.session_state["email"] = email | |
| if "message_limit" not in st.session_state: | |
| st.session_state["message_limit"] = 0 | |
| if "used_messages" not in st.session_state: | |
| st.session_state["used_messages"] = 0 | |
| def receive_wix_message(): | |
| components.html( | |
| """ | |
| <script> | |
| window.addEventListener('message', function(event) { | |
| const data = event.data; | |
| if (data.wixUserId && data.email) { | |
| window.parent.postMessage({ | |
| 'wix_user_id': data.wixUserId, | |
| 'email': data.email | |
| }, "*"); | |
| // Send message back to Streamlit | |
| window.parent.postMessage({ | |
| wix_user_id: data.wixUserId, | |
| email: data.email | |
| }, "*"); | |
| } | |
| }); | |
| </script> | |
| """, | |
| height=0 | |
| ) | |
| # Calling this function to initialize listening for Wix messages | |
| receive_wix_message() | |
| trust_tips = [ | |
| "What I don’t know I can’t trust you for. Make sure you know all your great TrustBuilders® and use them over time.", | |
| "The more specific, the more trustworthy each TrustBuilder® is.", | |
| "For TrustBuilders®, think about each Trust Bucket® and in each one organization, product, and key individuals.", | |
| "You are infinitely trustworthy. Organization, products, and your people. In each Trust Bucket® and past, present, and future.", | |
| "Some TrustBuilders® are enduring (we have over 3 million clients), others changing (we are ranked No. 1 for 8 years/9 years), and yet others short-lived (we will present at XYZ conference next month).", | |
| "Not all Trust Buckets® are equally important all the time. Think about which ones are most important right now and how to fill them (with TrustAnalyser® you know).", | |
| "In social media, structure posts over time to focus on different Trust Buckets® and themes within them.", | |
| "Try focusing your idea on specific Trust Buckets® or a mix of them.", | |
| "Within each Trust Bucket®, ask for examples across different themes like employee programs, IT, R&D.", | |
| "To create more and different trust, ask trustifier.ai to combine seemingly unconnected aspects like 'I played in bands all my youth. What does this add to my competence as a lawyer?'", | |
| "With every little bit more trust, your opportunity doubles. It's about using trustifier.ai to help you nudge trust up ever so slightly in everything you do.", | |
| "Being honest is not enough. You can be honest with one aspect and destroy trust and build a lot of trust with another. Define what that is.", | |
| "The more I trust you, the more likely I am to recommend you. And that's much easier with specifics.", | |
| "What others don’t say they are not trusted for - but you can claim that trust.", | |
| "Building more trust is a service to your audience. It's so valuable to us, as humans, that we reflect that value right away in our behaviors.", | |
| "In your audience journey, you can use TrustAnalyser® to know precisely which Trust Buckets® and TrustBuilders® are most effective at each stage of the journey.", | |
| "Try structuring a document. Like % use of each Trust Bucket® and different orders in the document.", | |
| "In longer documents like proposals, think about the chapter structure and which Trust Buckets® and TrustBuilders® you want to focus on when.", | |
| "Building Trust doesn’t take a long time. Trust is built and destroyed every second, with every word, action, and impression. That's why it's so important to build more trust all the time.", | |
| "There is no prize for the second most trusted. To get the most business, support, and recognition, you have to be the most trusted.", | |
| "With most clients, we know they don’t know 90% of their available TrustBuilders®. Knowing them increases internal trust - and that can be carried to the outside.", | |
| "Our client data always shows that, after price, trust is the key decision factor (and price is a part of benefit and relationship trust).", | |
| "Our client data shows that customer value increases 9x times from Trust Neutral to High Trust. A good reason for internal discussions.", | |
| "Our client's data shows that high trust customers are consistently far more valuable than just trusting ones.", | |
| "Trust determines up to 85% of your NPS. No wonder, because the more I trust you, the more likely I am to recommend you.", | |
| "Trust determines up to 75% of your loyalty. Think about it yourself. It's intuitive.", | |
| "Trust determines up to 87% of your reputation. Effectively, they are one and the same.", | |
| "Trust determines up to 85% of your employee engagement. But what is it that they want to trust you for?", | |
| "Don't just ask 'what your audience needs to trust for'. That just keeps you at low, hygiene trust levels. Ask what they 'would love to trust for'. That's what gets you to High Trust." | |
| ] | |
| suggestions = [ | |
| "Try digging deeper into a specific TrustBuilder®.", | |
| "Ask just for organization, product, or a person's TrustBuilders® for a specific Trust Bucket®.", | |
| "Some TrustBuilders® can fill more than one Trust Bucket®. We call these PowerBuilders. TrustAnalyser® reveals them for you.", | |
| "Building trust is storytelling. trustifier.ai connects Trust Buckets® and TrustBuilders® for you. But you can push it more to connect specific Trust Buckets® and TrustBuilders®.", | |
| "Describe your audience and ask trustifier.ai to choose the most relevant Trust Buckets®, TrustBuilders®, and tonality (TrustAnalyser® can do this precisely for you).", | |
| "Ask trustifier.ai to find TrustBuilders® for yourself. Then correct and add a few for your focus Trust Buckets® - and generate a profile or CV.", | |
| "LinkedIn Profiles are at their most powerful if they are regularly updated and focused on your objectives. Rewrite it every 2-3 months using different Trust Buckets®.", | |
| "Share more of your TrustBuilders® with others and get them to help you build your trust.", | |
| "Build a trust strategy. Ask trustifier.ai to find all your TrustBuilders® in the Trust Buckets® and then create a trust-building program for a specific person/audience over 8 weeks focusing on different Trust Buckets® that build on one another over time. Then refine and develop by channel ideas.", | |
| "Brief your own TrustBuilders® and ask trustifier.ai to tell you which Trust Buckets® they're likely to fill (some can fill more than one).", | |
| "Have some fun. Ask trustifier.ai to write a 200-word speech to investors using all Trust Buckets®, but leading and ending with Development Trust. Use [BRAND], product, and personal CEO [NAME] TrustBuilders®.", | |
| "Ask why TrustLogic® can be trusted in each Trust Bucket®.", | |
| "Ask what's behind TrustLogic®." | |
| ] | |
| def add_dot_typing_animation(): | |
| st.markdown( | |
| """ | |
| <style> | |
| .dots-container { | |
| display: flex; | |
| align-items: center; | |
| } | |
| .dot { | |
| height: 10px; | |
| width: 10px; | |
| margin: 0 5px; | |
| background-color: #bbb; | |
| border-radius: 50%; | |
| display: inline-block; | |
| animation: dot-blink 1.5s infinite ease-in-out; | |
| } | |
| .dot:nth-child(2) { | |
| animation-delay: 0.2s; | |
| } | |
| .dot:nth-child(3) { | |
| animation-delay: 0.4s; | |
| } | |
| @keyframes dot-blink { | |
| 0% { | |
| opacity: 0.3; | |
| } | |
| 20% { | |
| opacity: 1; | |
| } | |
| 100% { | |
| opacity: 0.3; | |
| } | |
| } | |
| </style> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| # Function to display the assistant typing dots | |
| def display_typing_indicator(): | |
| dot_typing_html = """ | |
| <div class="dots-container"> | |
| <span class="dot"></span> | |
| <span class="dot"></span> | |
| <span class="dot"></span> | |
| </div> | |
| """ | |
| st.markdown(dot_typing_html, unsafe_allow_html=True) | |
| def display_save_confirmation(type_saved): | |
| st.info(f"Content successfully saved as **{type_saved}**!") | |
| if "trustbuilders" not in st.session_state: | |
| st.session_state["trustbuilders"] = {} | |
| if "brand_tonality" not in st.session_state: | |
| st.session_state["brand_tonality"] = {} | |
| # Load saved entries upon user login | |
| def retrieve_user_data(user_id): | |
| """ | |
| Load all content for a user from Firebase, ensuring each user has a single root | |
| containing TrustBuilder, BrandTonality, and other data fields like email, message limits, etc. | |
| """ | |
| try: | |
| user_data = db.child("users").child(user_id).get().val() | |
| if user_data: | |
| # Update session state with all user data | |
| st.session_state.update(user_data) | |
| # Load TrustBuilder and BrandTonality into session state for display | |
| st.session_state["TrustBuilder"] = user_data.get("TrustBuilder", {}) | |
| st.session_state["BrandTonality"] = user_data.get("BrandTonality", {}) | |
| except Exception as e: | |
| st.error(f"Error loading saved content: {e}") | |
| def handle_memory_queries(prompt): | |
| """ | |
| Main function to handle user commands and allocate Trust Buckets. | |
| """ | |
| prompt = prompt.strip() | |
| valid_buckets = ["Stability", "Development", "Relationship", "Benefit", "Vision", "Competence"] | |
| # Case 1: Save this as [bucket] trust builder: [content] | |
| match_save_this_specific = re.search(r"\bsave\s+(this\s+)?as\s+(\w+)\s+trust\s+builders?\s*:\s*(.+)", prompt, re.IGNORECASE) | |
| if match_save_this_specific: | |
| specified_bucket = match_save_this_specific.group(2).capitalize() | |
| content_to_save = match_save_this_specific.group(3).strip() | |
| if specified_bucket in valid_buckets: | |
| if content_to_save: | |
| assistant_response = handle_save_trustbuilder(content_to_save, specified_bucket) | |
| else: | |
| assistant_response = "No content provided. Please include content after 'save this as [bucket] trust builder:'." | |
| else: | |
| assistant_response = f"Invalid Trust Bucket '{specified_bucket}'. Valid buckets are: {', '.join(valid_buckets)}." | |
| # Save response to chat history and display it | |
| st.session_state.chat_history.append({"role": "assistant", "content": assistant_response}) | |
| with st.chat_message("assistant"): | |
| st.markdown(assistant_response) | |
| return None | |
| # Case 2: Save this under [bucket]: [content] | |
| match_save_under_specific = re.search(r"\bsave\s+(this\s+)?under\s+(\w+)\s*:\s*(.+)", prompt, re.IGNORECASE) | |
| if match_save_under_specific: | |
| specified_bucket = match_save_under_specific.group(2).capitalize() | |
| content_to_save = match_save_under_specific.group(3).strip() | |
| if specified_bucket in valid_buckets: | |
| if content_to_save: | |
| assistant_response = handle_save_trustbuilder(content_to_save, specified_bucket) | |
| else: | |
| assistant_response = "No content provided. Please include content after 'save this under [bucket]:'." | |
| else: | |
| assistant_response = f"Invalid Trust Bucket '{specified_bucket}'. Valid buckets are: {', '.join(valid_buckets)}." | |
| # Save response to chat history and display it | |
| st.session_state.chat_history.append({"role": "assistant", "content": assistant_response}) | |
| with st.chat_message("assistant"): | |
| st.markdown(assistant_response) | |
| return None | |
| # Case 3: Save and allocate: [content] (automatic allocation) | |
| match_save_allocate_auto = re.search(r"\bsave\s+(this\s+)?and\s+allocate\s*:\s*(.+)", prompt, re.IGNORECASE) | |
| if match_save_allocate_auto: | |
| content_to_save = match_save_allocate_auto.group(2).strip() | |
| if content_to_save: | |
| assistant_response = handle_save_trustbuilder(content_to_save) # Automatically allocate bucket | |
| else: | |
| assistant_response = "No content provided. Please include content after 'save and allocate:'." | |
| # Save response to chat history and display it | |
| st.session_state.chat_history.append({"role": "assistant", "content": assistant_response}) | |
| with st.chat_message("assistant"): | |
| st.markdown(assistant_response) | |
| return | |
| elif "find my saved trustbuilders" in prompt or "show my saved trustbuilders" in prompt: | |
| trustbuilders = fetch_trustbuilders(st.session_state.get("wix_user_id", "default_user")) | |
| if trustbuilders: | |
| saved_content = "\n".join([f"- {entry['message']}" for entry in trustbuilders.values()]) | |
| assistant_response = f"Here are your saved TrustBuilders:\n{saved_content}" | |
| else: | |
| assistant_response = "You haven't saved any TrustBuilders yet." | |
| # Save response to chat history and display it | |
| st.session_state.chat_history.append({"role": "assistant", "content": assistant_response}) | |
| with st.chat_message("assistant"): | |
| st.markdown(assistant_response) | |
| return None | |
| def handle_save_trustbuilder(content, specified_bucket=None): | |
| """ | |
| Handles saving TrustBuilders by detecting or automatically allocating the Trust Bucket. | |
| """ | |
| # Avoid reprocessing the same content | |
| if "last_processed_content" in st.session_state and st.session_state["last_processed_content"].lower() == content.lower(): | |
| return None # Exit if the content was already processed | |
| trust_buckets = { | |
| "Stability": [ | |
| "track record", "longevity", "size", "stability", "experience", "established", "heritage", | |
| "continuity", "reliable", "secure", "trustworthy", "dependable", "durable", "assurance", | |
| "foundation", "longstanding", "rooted", "strong", "solid", "proven", "milestones", | |
| "geographic footprint", "history", "recognizable", "retention", "consistent", "employees", | |
| "families", "recognition", "awards" | |
| ], | |
| "Development": [ | |
| "innovation", "investment", "future-focused", "cutting-edge", "leadership", "growth", | |
| "ambition", "strategy", "adaptation", "forward-thinking", "evolve", "progress", | |
| "pilot programs", "technology", "training", "pioneering", "future-proof", "patents", | |
| "pipeline", "biotechnology", "adapt", "change", "radical", "sustainable" | |
| ], | |
| "Relationship": [ | |
| "collaboration", "support", "empathy", "engagement", "customer-focused", "community", | |
| "partnership", "bond", "interaction", "sensitivity", "diversity", "social responsibility", | |
| "inclusive", "well-being", "investment", "communication", "feedback", "employee benefits", | |
| "customer councils", "loyalty", "wellness", "stakeholder", "inclusive initiatives", | |
| "social awareness", "active engagement", "connected" | |
| ], | |
| "Benefit": [ | |
| "value", "benefit", "growth", "success", "advantage", "efficiency", "satisfaction", | |
| "reward", "functional value", "emotional value", "unique", "output", "results", "superior", | |
| "return", "proposition", "cost savings", "improvements", "enjoyment", "peace of mind", | |
| "confidence", "methodologies", "results", "growth strategy", "improvement", "continuous" | |
| ], | |
| "Vision": [ | |
| "goal", "mission", "aspire", "dream", "visionary", "great", "future", "ideal", "ambition", | |
| "long-term", "objective", "focus", "drive", "purpose", "values", "integrity", | |
| "philanthropy", "social impact", "ethical", "society", "inspire", "sustainability", | |
| "impact", "initiatives", "greater good", "common good", "compelling", "volunteering" | |
| ], | |
| "Competence": [ | |
| "expertise", "skills", "innovation", "excellence", "knowledge", "capability", | |
| "proficiency", "technical", "problem-solving", "methodologies", "effectiveness", | |
| "specialization", "certifications", "creativity", "collaboration", "leadership", | |
| "capabilities", "accreditations", "teamwork", "publications", "training", "patents", | |
| "high-profile", "results-oriented", "proven ability", "credentials", "creative excellence" | |
| ] | |
| } | |
| bucket = specified_bucket | |
| # Automatically allocate bucket if not provided | |
| if not bucket: | |
| for tb, keywords in trust_buckets.items(): | |
| if any(keyword in content.lower() for keyword in map(str.lower, keywords)): | |
| bucket = tb | |
| break | |
| # If no bucket can be allocated, prompt the user | |
| if not bucket: | |
| st.session_state["missing_trustbucket_content"] = content | |
| return ( | |
| "No Trust Bucket could be allocated automatically. " | |
| "Please indicate the Trust Bucket (e.g., Stability, Development, Relationship, Benefit, Vision, Competence)." | |
| ) | |
| # Save TrustBuilder with detected/provided bucket | |
| brand = st.session_state.get("brand_input_save", "Unknown") | |
| content_to_save = f"{bucket}: Brand: {brand.strip()} | {content.strip()}" | |
| save_content(st.session_state["wix_user_id"], content_to_save) | |
| # Update last processed content | |
| st.session_state["last_processed_content"] = content | |
| # Confirm saving to the user | |
| return f"TrustBuilder allocated to **{bucket}** and saved successfully!" | |
| def delete_entry(category, entry_id): | |
| try: | |
| user_id = st.session_state["wix_user_id"] | |
| db.child("users").child(user_id).child(category).child(entry_id).remove() | |
| st.session_state[category].pop(entry_id, None) | |
| st.success(f"{category} entry deleted successfully!") | |
| except Exception as e: | |
| st.error(f"Error deleting entry: {e}") | |
| # Function to download TrustBuilder as a .md file | |
| def download_trustbuilder_as_md(content, trustbuilder_id): | |
| b64_content = base64.b64encode(content.encode()).decode() | |
| download_link = f'<a href="data:text/markdown;base64,{b64_content}" download="TrustBuilder_{trustbuilder_id}.md">Download</a>' | |
| st.sidebar.markdown(download_link, unsafe_allow_html=True) | |
| def load_user_memory(user_id): | |
| """ | |
| Load saved TrustBuilders and uploaded documents from Firebase into session state. | |
| """ | |
| try: | |
| # Load TrustBuilders | |
| trustbuilders = db.child("users").child(user_id).child("TrustBuilders").get().val() | |
| st.session_state["trustbuilders"] = trustbuilders if trustbuilders else [] | |
| # Load Uploaded Documents from 'KnowledgeBase' | |
| documents = db.child("users").child(user_id).child("KnowledgeBase").get().val() | |
| st.session_state["documents"] = documents if documents else {} | |
| # Reconstruct vector stores for each document | |
| st.session_state["vector_store"] = {} | |
| for doc_id, doc_data in st.session_state["documents"].items(): | |
| content = doc_data.get("content", "") | |
| if content: | |
| index_document_content(content, doc_id) | |
| except Exception as e: | |
| st.error(f"Error loading user memory: {e}") | |
| st.session_state["trustbuilders"] = [] | |
| st.session_state["documents"] = {} | |
| st.session_state["vector_store"] = {} | |
| def clean_and_format_markdown(raw_text): | |
| """ | |
| Dynamically cleans and formats Markdown text to ensure URLs are properly encoded | |
| and handles issues with line breaks or improperly formatted Markdown. | |
| """ | |
| # Regular expression to find Markdown links [text](url) | |
| pattern = r'\[([^\]]+)\]\(([^)]+)\)' | |
| def encode_url(match): | |
| text = match.group(1) | |
| url = match.group(2).strip() # Remove leading/trailing spaces | |
| encoded_url = quote(url, safe=':/') # Encode the URL while keeping : and / | |
| return f"[{text}]({encoded_url})" | |
| # Fix Markdown links dynamically | |
| formatted_text = re.sub(pattern, encode_url, raw_text) | |
| # Replace single newlines with spaces to avoid breaking Markdown rendering | |
| formatted_text = re.sub(r"(?<!\n)\n(?!\n)", " ", formatted_text) | |
| return formatted_text | |
| if "missing_trustbucket_content" not in st.session_state: | |
| st.session_state["missing_trustbucket_content"] = None | |
| if "handled" not in st.session_state: | |
| st.session_state["handled"] = False | |
| def clean_and_format_markdown(text: str) -> str: | |
| # Normalize Unicode | |
| text = unicodedata.normalize('NFKC', text) | |
| # Remove zero-width and other invisible chars | |
| text = re.sub(r'[\u200B\uFEFF\u200C\u200D]', '', text) | |
| # Remove control characters | |
| text = re.sub(r'[\x00-\x1F\x7F-\x9F]', '', text) | |
| # Replace escaped and actual newlines with a single space | |
| text = text.replace('\\n', ' ').replace('\n', ' ') | |
| # Remove HTML tags if any | |
| text = re.sub(r'<[^>]*>', '', text) | |
| # Ensure space after punctuation if missing | |
| text = re.sub(r'([.,!?])(\S)', r'\1 \2', text) | |
| # Ensure spacing between numbers and letters | |
| text = re.sub(r'(\d)([A-Za-z])', r'\1 \2', text) | |
| text = re.sub(r'([A-Za-z])(\d)', r'\1 \2', text) | |
| # Normalize multiple spaces | |
| text = re.sub(r'\s+', ' ', text).strip() | |
| return text | |
| prompt = st.chat_input("") | |
| global combined_text | |
| def handle_prompt(prompt): | |
| if "main_faiss_db" not in st.session_state: | |
| refresh_main_faiss_index() | |
| if prompt: | |
| st.session_state.chat_started = True | |
| # Prevent duplicate messages in chat history | |
| if not any(msg["content"] == prompt for msg in st.session_state["chat_history"]): | |
| st.session_state.chat_history.append({"role": "user", "content": prompt}) | |
| st.session_state["handled"] = False | |
| # Handle missing Trust Bucket if needed | |
| if st.session_state.get("missing_trustbucket_content") and not st.session_state["handled"]: | |
| bucket = prompt.strip().capitalize() | |
| valid_buckets = ["Stability", "Development", "Relationship", "Benefit", "Vision", "Competence"] | |
| if bucket in valid_buckets: | |
| content_to_save = st.session_state.pop("missing_trustbucket_content") | |
| handle_save_trustbuilder(content_to_save, bucket) | |
| else: | |
| with st.chat_message("assistant"): | |
| st.markdown("Invalid Trust Bucket. Please choose from Stability, Development, Relationship, Benefit, Vision, or Competence.") | |
| st.session_state["handled"] = True | |
| # Handle fetching saved TrustBuilders when user asks | |
| if ("find my saved trustbuilders" in prompt.lower() or "show my saved trustbuilders" in prompt.lower()) and not st.session_state["handled"]: | |
| trustbuilders = fetch_trustbuilders(st.session_state.get("wix_user_id", "default_user")) | |
| if trustbuilders: | |
| saved_content = "\n".join([f"- {entry}" for entry in trustbuilders]) | |
| assistant_response = f"Here are your saved TrustBuilders:\n{saved_content}" | |
| else: | |
| assistant_response = "You haven't saved any TrustBuilders yet." | |
| # Append assistant's response to chat history | |
| st.session_state.chat_history.append({"role": "assistant", "content": assistant_response}) | |
| with st.chat_message("assistant"): | |
| st.markdown(assistant_response) | |
| st.session_state["handled"] = True | |
| # Handle save TrustBuilder command | |
| if not st.session_state["handled"]: | |
| save_match = re.search(r"\b(save|add|keep|store)\s+(this)?\s*(as)?\s*(\w+\s*trustbuilder|trustbuilder)\s*:?(.+)?", prompt, re.IGNORECASE) | |
| if save_match: | |
| content_to_save = save_match.group(5).strip() if save_match.group(5) else None | |
| specified_bucket = None | |
| # Check for explicit bucket mention in the same prompt | |
| bucket_match = re.search(r"\b(stability|development|relationship|benefit|vision|competence)\b", prompt, re.IGNORECASE) | |
| if bucket_match: | |
| specified_bucket = bucket_match.group(1).capitalize() | |
| if content_to_save: | |
| handle_save_trustbuilder(content_to_save, specified_bucket) | |
| else: | |
| # If content is not provided after the command, extract from prompt | |
| content_to_save = re.sub(r"\b(save|add|keep|store)\s+(this)?\s*(as)?\s*(\w+\s*trustbuilder|trustbuilder)\b", "", prompt, flags=re.IGNORECASE).strip() | |
| if content_to_save: | |
| handle_save_trustbuilder(content_to_save, specified_bucket) | |
| else: | |
| with st.chat_message("assistant"): | |
| st.markdown("Please provide the content to save as a TrustBuilder.") | |
| # Mark as handled and exit to prevent further processing | |
| st.session_state["handled"] = True | |
| return # Exit here to avoid triggering normal AI response | |
| # Handle other memory queries if any | |
| if not st.session_state["handled"]: | |
| memory_response = handle_memory_queries(prompt) | |
| if memory_response == "find_my_saved_trustbuilders": | |
| # This case is already handled above, so we can set handled to True | |
| st.session_state["handled"] = True | |
| elif memory_response: | |
| with st.chat_message("assistant"): | |
| st.markdown(memory_response) | |
| st.session_state["handled"] = True | |
| # If not handled yet, proceed to the existing AI response generation | |
| if not st.session_state["handled"]: | |
| # Generate a response with AI for other types of queries | |
| with st.chat_message("user"): | |
| st.markdown(prompt) | |
| response_placeholder = st.empty() | |
| with response_placeholder: | |
| with st.chat_message("assistant"): | |
| add_dot_typing_animation() | |
| display_typing_indicator() | |
| cleaned_text = "" | |
| # base_instructions = """ | |
| # Avoid Flowery language and ai words.Be over specific with numbers,names,dollars, programs ,awards and action* | |
| # 1. **Adhere to Uploaded Document's Style**: | |
| # - When asked uploaded files or document means knowledgebase. | |
| # - Use the uploaded document as a primary guide for writing style, tone, and structure. Just directly give response. | |
| # - Match formatting such as headings, subheadings, and paragraph styles. If the uploaded document lacks headings, Strictly do not include them in the response. | |
| # 2. **Prioritize Knowledge Base and Internet Sources**: | |
| # - Use uploaded documents or knowledge base files as the primary source. | |
| # - Perform a Google search to retrieve valid and correct internet links for references, ensuring only accurate and verified source links are used. | |
| # 3. **Avoid Flowery Language and AI Jargon**: | |
| # - Use clear, professional language without exaggerated or vague expressions. Avoid jargon like "beacon," "realm," "exemplifies," etc. | |
| # 4. **Ensure Accuracy**: | |
| # - Provide only verifiable and accurate information. Do not include placeholders, fabricated URLs, or vague references. | |
| # """ | |
| base_instructions=""" | |
| **General Guidelines**: | |
| - Use **clear, professional language** without exaggerated expressions or AI words, jargon (e.g., "beacon," "realm," "exemplifies"). | |
| - Always include **specific numbers, names, dollar amounts, programs, awards, and actions** when identifying TrustBuilders®. | |
| **Formatting and Accuracy**: | |
| - Ensure responses are properly formatted and free of errors. | |
| - Respond in the same language as the query. | |
| - Provide **accurate source links** for all TrustBuilders® mentioned in a separate section. | |
| **Avoid**: | |
| - Flowery language , AI JARGONS AND WORDS. | |
| - Isolated facts—ensure logical connections between ideas to maintain flow and thematic consistency. | |
| - Repetition or mechanical structures. | |
| Detect user language and respond in same language user. | |
| """ | |
| # Check if user request includes blog, article, or newsletter | |
| if any(keyword in prompt.lower() for keyword in [ | |
| "blog", "article", "annual report", "report", "newsletter", "news letter", | |
| "website introduction", "intro", "website copy", "day-to-day email", | |
| "sales email", "proposal", "case study", "social media post", "press release", | |
| "executive profile", "fundraising email", "speech writing", "brand story", | |
| "product description", "advertising copy", "landing page copy", | |
| "seo blog article", "tagline", "slogan", "customer value proposition", | |
| "employee value proposition", "negotiation", "sales conversation", | |
| "customer testimonial", "sales deck content", "webinar", | |
| "event invitation", "white paper", "thought leadership article", | |
| "corporate announcement", "company newsletter", "investor article", | |
| "crisis communication", "panel discussion prep", "linkedin profile", | |
| "website team profile", "speaker bio", "board member profile", | |
| "customer onboarding email", "apology & service recovery email", | |
| "job ad", "job description", "employee newsletter", | |
| "company culture & values page", "internal memo", "performance review", | |
| "partner profile","profiles","Proposal","Proposal introductions" | |
| ]): | |
| appended_instructions = ( | |
| """ | |
| **Craft flawless, engaging content using clear, direct, non-flowery language that actively captivates readers. Avoid AI jargon, vague phrases, or overly formal wording. Follow industry-standard formats strictly. Write headlines and sentences exclusively in active voice—avoid passive constructions entirely.** | |
| --- | |
| DONOT MENTION TRUSTBUCKET NAME IN THE OUTPUT. AVOID IT. | |
| ## **Mandatory Guidelines for Partner Profiles** | |
| - Format Partner Profiles as a continuous, cohesive narrative without sub-lines, mini-headings, or sectioned headings. | |
| - Include **one compelling quote** in bold with spacing , formatted similarly to partner profiles on BCLP Law’s website ([example](https://www.bclplaw.com/en-US/people/tom-bacon.html)): | |
| - Place the quote in quotation marks, and ensure it succinctly captures the individual's expertise, values, or professional philosophy. | |
| - Attribute clearly if necessary. | |
| - Highlight specific achievements, areas of expertise, leadership roles, and notable contributions. | |
| - Ensure seamless narrative flow without any sectioned headings or bullet points. | |
| ## **General Guidelines for All Formats** | |
| Strictly give headings and sub-headings . and Subject where necessary | |
| DONOT MENTION TRUSTBUCKET NAMES LITERALLY | |
| 1. **Seamless Flow (Critical for All Formats)** | |
| - Every paragraph must connect logically to the previous one and transition naturally into the next. | |
| - Use linking phrases like "Building on this..." or "This aligns with..." to reinforce the narrative's interconnectedness. | |
| - Ensure no standalone or disjointed sections; the content should flow as one cohesive story. | |
| 2. **Tailored Formats** | |
| - **Blogs/Articles/Reports/Annual Reports**: | |
| - In-depth narrative paragraphs, creative subheadings, real-world examples. | |
| - **Newsletters**: | |
| - Short paragraphs/bullet points, direct "you/your" engagement, strong CTAs. | |
| - Donot include source link within content only in list of trustbuilders | |
| - **Partner Profiles** *(Important addition you have now)*: | |
| - Continuous narrative without sub-lines or headings. | |
| - Include a compelling professional quote. | |
| - Follow the structure of BCLP profiles precisely. | |
| - **Social Media Posts, Sales Emails, Proposals, Case Studies, etc.**: | |
| - Concise, specific, action-oriented text with concrete examples, statistics, awards, and impactful details. | |
| 3. **Dynamic Headlines and Subheadings** | |
| - Create active, action-oriented headlines summarizing the content below (e.g., "Transform Lives Today" rather than "Transforming Lives"). | |
| - Avoid generic titles or "-ing" endings. Headlines should inspire curiosity and guide the reader through the content. | |
| 4. **Relatable, Audience-Centric Tone** | |
| - Address the audience directly ("you") to make the content feel personal, especially in newsletters. | |
| - Tailor the content to the audience's needs, challenges, and aspirations. | |
| - Use vivid imagery, relatable examples, and emotional appeals to create engagement. | |
| 5. **Purpose-Driven Impact** | |
| - Define and achieve the content’s purpose—whether to inform, persuade, or inspire action. | |
| - Ensure each paragraph contributes to the overall objective while reinforcing the key message. | |
| 6. **Polished and Professional Presentation** | |
| - Deliver error-free, well-structured content with visually appealing layouts. | |
| - Ensure concise paragraphs and bullet points highlight key statistics or achievements. | |
| --- | |
| ## **Mandatory Guidelines ** | |
| 1. ** Formatting** | |
| - Use short, impactful paragraphs or bullet points to improve readability. | |
| - Ensure content is visually digestible, with clear section breaks and prominent CTAs. | |
| - Example CTA: "Be the hope they need—donate today." | |
| 2. **TrustBuilder Integration** | |
| - Weave TrustBuilders® naturally into the narrative without isolating them. | |
| - Highlight relevance subtly while maintaining readability. | |
| 3. **Mandatory Sections** | |
| - **Engaging Opening**: Start with a compelling hook to draw the reader in. | |
| - Example: "Imagine transforming the life of a child in need—your support can make this possible." | |
| - **Highlight Initiatives**: Summarize key programs, achievements, and their impacts. | |
| - Example Headline: "Empower Communities Through Early Education" | |
| - **Leadership and Success Stories**: Highlight leadership contributions or personal stories that inspire confidence. | |
| - Example Headline: "DrivE Change with Strategic Leadership" | |
| - **Bolder Call-to-Action (CTA) **: End with a powerful CTA that encourages immediate reader engagement. | |
| 4. **Headlines**: | |
| - *Always Give active language main headline and sub headlines with paragraphs, should be creative. | |
| --- | |
| ## **Mandatory Guidelines ** | |
| 1. **Blog/Article-Specific Formatting** | |
| - Stronger Emotional Hook at the Start | |
| - Use in-depth, narrative-style paragraphs to explore topics comprehensively. | |
| - Ensure each section begins with a creative subheading summarizing its content. | |
| - Focus on storytelling techniques to maintain reader interest. | |
| - Bring More Engaging Transitions Between Sections. | |
| 2. **Detailed Content Elements** | |
| - Include real-world examples and data to support claims. | |
| - Use actionable insights to provide value to the reader. | |
| 3. **Interconnected Narrative** | |
| - Ensure every paragraph connects logically to the previous one, building a seamless flow throughout. | |
| - Use phrases to maintain cohesiveness. | |
| 4. **Headlines**: | |
| - Give active language main headline and sub-headlines with each paragraphs, should be creative. | |
| --- | |
| ## **Key Components for All Formats** | |
| 1. **TrustBuilders and Techniques** | |
| - **List of TrustBuilders Used**: List TrustBuilders used along with source links. | |
| Add in footnote style: | |
| - **Heuristics**: Mention names only (e.g., Social Proof, Authority, Commitment). | |
| - **Creative Techniques**: Mention names only (e.g., Storytelling, Emotional Appeal). | |
| 2. **Creative Headlines and Subheadings** | |
| - Use dynamic, action-driven only acive voice strictly headlines to engage the reader. | |
| - Example: "Empower Strategic Growth and Development" or "Create Lasting Impact Together" | |
| 3. **Actionable CTAs** | |
| - Include Bolder Call-to-Action that inspire action at the end of relevant sections. | |
| --- | |
| ## **Critical Reminders** | |
| - Strengthen connections between paragraphs to create a seamless flow. | |
| - Balance brevity and detail to suit the format (blogs/articles for depth, newsletters for quick summaries). | |
| - Maintain a cohesive tone and structure across all formats. | |
| """) | |
| else: | |
| appended_instructions = "" | |
| final_prompt = f"{prompt} {base_instructions} {appended_instructions}" | |
| global formatted_text | |
| # Specialized responses if keywords detected | |
| try: | |
| output = agent_executor.invoke({ | |
| "input": final_prompt, | |
| "chat_history": st.session_state.chat_history | |
| }) | |
| full_response = output["output"] | |
| import html | |
| escaped_text = full_response.replace("$", "\$") | |
| trust_tip, suggestion = get_trust_tip_and_suggestion() | |
| combined_text = f"{escaped_text}\n\n---\n\n**Trust Tip**: {trust_tip}\n\n**Suggestion**: {suggestion}" | |
| #formatted_text = clean_and_format_markdown(combined_text) | |
| with response_placeholder: | |
| with st.chat_message("assistant"): | |
| st.markdown(combined_text) | |
| st.session_state.chat_history.append({"role": "assistant", "content": escaped_text}) | |
| copy_to_clipboard(combined_text) | |
| except Exception as e: | |
| logging.error(f"Error generating response: {e}") | |
| st.error("An error occurred while generating the response. Please try again.") | |
| st.session_state["handled"] = True # Mark as handled | |
| handle_prompt(prompt) | |