Track funding rounds, investors, and trends in climate technology startups
', unsafe_allow_html=True) def load_data(filepath): """ Load data from a JSON file and return as a pandas DataFrame. Args: filepath (str): Path to the JSON file Returns: pd.DataFrame: DataFrame with 'Funding Date' column converted to datetime """ import json try: # Read the JSON file as text first with open(filepath, 'r', encoding='utf-8') as file: content = file.read().strip() # Wrap the content in square brackets to make it a proper JSON array if not content.startswith('['): content = '[' + content + ']' # Parse the JSON data = json.loads(content) # Create DataFrame from the list of dictionaries df = pd.DataFrame(data) # Convert 'Funding Date' column to datetime objects df['Funding Date'] = pd.to_datetime(df['Funding Date']) # Clean Amount column - replace infinite and NaN values with 0 if 'Amount' in df.columns: df['Amount'] = pd.to_numeric(df['Amount'], errors='coerce') # Convert to numeric, NaN for invalid df['Amount'] = df['Amount'].replace([float('inf'), -float('inf')], 0) # Replace infinite with 0 df['Amount'] = df['Amount'].fillna(0) # Replace NaN with 0 return df except Exception as e: st.error(f"Error loading data: {str(e)}") return pd.DataFrame() # Return empty DataFrame on error def create_investor_summary(df, lead_only=False): """ Create an investor-centric summary DataFrame from deals data. Args: df (pd.DataFrame): Original deals DataFrame lead_only (bool): If True, only include lead investors Returns: pd.DataFrame: Investor summary with metrics """ investor_data = [] # Get all unique investors from both columns all_investors = set() for _, row in df.iterrows(): # Parse lead investors lead_investors = str(row['Lead Investor(s)']).split(', ') if pd.notna(row['Lead Investor(s)']) else [] other_investors = str(row['Other Investors']).split(', ') if pd.notna(row['Other Investors']) else [] # Clean and add investors (skip "Not specified") for investor in lead_investors: investor = investor.strip() if investor and investor != "Not specified" and investor != "nan": all_investors.add(investor) # Add other investors only if not lead_only if not lead_only: for investor in other_investors: investor = investor.strip() if investor and investor != "Not specified" and investor != "nan": all_investors.add(investor) # Calculate metrics for each investor for investor in all_investors: investor_deals = [] total_invested = 0 verticals = [] stages = [] lead_deals = 0 # Find all deals this investor participated in for _, row in df.iterrows(): lead_investors = str(row['Lead Investor(s)']).split(', ') if pd.notna(row['Lead Investor(s)']) else [] other_investors = str(row['Other Investors']).split(', ') if pd.notna(row['Other Investors']) else [] # Clean investor names for comparison lead_investors = [inv.strip() for inv in lead_investors] other_investors = [inv.strip() for inv in other_investors] # Check participation is_lead = investor in lead_investors is_other = investor in other_investors if is_lead or (is_other and not lead_only): investor_deals.append(row) # Safely add amount, handling NaN and infinite values amount = row['Amount'] if pd.notna(amount) and not math.isinf(amount): total_invested += amount verticals.append(row['Climate Vertical']) stages.append(row['Funding Stage']) if is_lead: lead_deals += 1 # Calculate preferred verticals (top 2-3) vertical_counts = pd.Series(verticals).value_counts() preferred_verticals = vertical_counts.head(3).index.tolist() # Calculate preferred stages (top 2-3) stage_counts = pd.Series(stages).value_counts() preferred_stages = stage_counts.head(3).index.tolist() investor_data.append({ 'Investor Name': investor, 'Deals Done': len(investor_deals), 'Lead Deals': lead_deals, 'Total Invested': total_invested, 'Preferred Verticals': ', '.join(preferred_verticals), 'Preferred Stages': ', '.join(preferred_stages) }) # Create DataFrame and sort by total invested investor_df = pd.DataFrame(investor_data) investor_df = investor_df.sort_values('Total Invested', ascending=False).reset_index(drop=True) return investor_df def get_investor_deals(df, investor_name): """ Get all deals for a specific investor. Args: df (pd.DataFrame): Original deals DataFrame investor_name (str): Name of the investor Returns: pd.DataFrame: All deals this investor participated in """ investor_deals = [] for _, row in df.iterrows(): lead_investors = str(row['Lead Investor(s)']).split(', ') if pd.notna(row['Lead Investor(s)']) else [] other_investors = str(row['Other Investors']).split(', ') if pd.notna(row['Other Investors']) else [] # Clean investor names for comparison lead_investors = [inv.strip() for inv in lead_investors] other_investors = [inv.strip() for inv in other_investors] if investor_name in lead_investors or investor_name in other_investors: # Add role information role = "Lead" if investor_name in lead_investors else "Other" row_dict = row.to_dict() row_dict['Role'] = role investor_deals.append(row_dict) return pd.DataFrame(investor_deals) def categorize_deal_size(amount): """ Categorize deal size into buckets relevant to funding stages. Args: amount (float): Deal amount in USD Returns: str: Deal size category """ if amount < 1_000_000: return "Pre-Seed (<$1M)" elif amount <= 5_000_000: return "Seed ($1M-$5M)" elif amount <= 20_000_000: return "Series A ($5M-$20M)" else: return "Series B+ (>$20M)" def add_geography_column(df): """ Add geography information based on investor names and known patterns. This is a simplified approach - in production, you'd have a proper database. Args: df (pd.DataFrame): Original deals DataFrame Returns: pd.DataFrame: DataFrame with Geography column added """ df = df.copy() # Simple geography mapping based on known investor patterns # This is a basic implementation - in reality you'd have a comprehensive database north_america_indicators = [ 'ventures', 'capital', 'partners', 'fund', 'investment', 'vc', 'sequoia', 'andreessen', 'kleiner', 'accel', 'benchmark', 'greylock', 'first round', 'union square', 'spark', 'foundry', 'insight', 'general catalyst', 'nea', 'khosla', 'draper', 'sv angel' ] europe_indicators = [ 'european', 'london', 'berlin', 'paris', 'stockholm', 'amsterdam', 'atomico', 'balderton', 'accel', 'index', 'northzone', 'creandum', 'eurazeo', 'lakestar', 'rocket', 'target global' ] def determine_geography(lead_investors, other_investors): all_investors = str(lead_investors).lower() + ' ' + str(other_investors).lower() # Count indicators for each region na_score = sum(1 for indicator in north_america_indicators if indicator in all_investors) eu_score = sum(1 for indicator in europe_indicators if indicator in all_investors) if na_score > eu_score: return "North America" elif eu_score > na_score: return "Europe" else: return "Global/Other" # Apply geography determination df['Geography'] = df.apply( lambda row: determine_geography(row['Lead Investor(s)'], row['Other Investors']), axis=1 ) return df def extract_data_with_ai(url): """ Extract funding data from a news article URL using AI. Args: url (str): URL of the news article Returns: dict: Extracted funding data or error message """ try: # Step A: Fetch and parse the article text headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'} response = requests.get(url, headers=headers) soup = BeautifulSoup(response.content, 'html.parser') # Find the main article body (this might need tuning for different sites) article_text = ' '.join(p.get_text() for p in soup.find_all('p')) if not article_text: return {"error": "Could not extract text from the article."} # Step B: Call the OpenAI API system_prompt = """ You are an expert financial analyst. Extract the following information from the article text provided. Respond ONLY with a valid JSON object. If information is not found, use null. The schema is: {"companyName": "string", "amount": integer, "currency": "string", "fundingStage": "string", "leadInvestors": ["string"], "otherInvestors": ["string"], "climateVertical": "string"} """ # Check if OpenAI API key is available and valid try: api_key = st.secrets.get("OPENAI_API_KEY", "") if not api_key or api_key == "your-openai-api-key-here": return {"error": "OpenAI API key not configured. Please add a valid OPENAI_API_KEY to .streamlit/secrets.toml"} except Exception: return {"error": "No secrets found. Please create .streamlit/secrets.toml with OPENAI_API_KEY"} openai.api_key = api_key response = openai.chat.completions.create( model="gpt-3.5-turbo", messages=[ {"role": "system", "content": system_prompt}, {"role": "user", "content": article_text[:4000]} # Truncate to fit model context limit ] ) # Step C: Return the structured data return json.loads(response.choices[0].message.content) except Exception as e: error_msg = str(e) if "429" in error_msg or "insufficient_quota" in error_msg or "quota" in error_msg.lower(): return {"error": "OpenAI API quota exceeded. Please check your billing at https://platform.openai.com/usage and add credits to your account."} elif "401" in error_msg or "invalid" in error_msg.lower(): return {"error": "Invalid OpenAI API key. Please check your API key at https://platform.openai.com/api-keys"} else: return {"error": f"An error occurred: {error_msg}"} def format_currency(amount): """ Format currency amounts to be human-readable. Args: amount (float): Amount to format Returns: str: Formatted currency string """ # Handle NaN, None, and infinite values if pd.isna(amount) or amount is None: return "$0" if math.isinf(amount): return "N/A" # Convert to float and handle any remaining edge cases try: amount = float(amount) except (ValueError, TypeError): return "$0" # Handle negative values if amount < 0: return f"-{format_currency(abs(amount))}" # Format based on magnitude if amount >= 1_000_000_000: return f"${amount / 1_000_000_000:.1f}B" if amount >= 1_000_000: return f"${amount / 1_000_000:.1f}M" if amount >= 1_000: return f"${amount / 1_000:.1f}K" return f"${amount:.0f}" def display_investor_profile(df, investor_name): """ Display detailed profile page for a specific investor. Args: df (pd.DataFrame): Original deals DataFrame investor_name (str): Name of the investor """ # Header with investor name st.header(f"👤 {investor_name}") # Back to list button if st.button("← Back to Investor List"): st.session_state.selected_investor = None st.rerun() # Get investor's deals investor_deals_df = get_investor_deals(df, investor_name) if investor_deals_df.empty: st.warning("No deals found for this investor.") return # Calculate investor-specific KPIs total_deals = len(investor_deals_df) total_invested = investor_deals_df['Amount'].sum() # Get preferred verticals and stages verticals = investor_deals_df['Climate Vertical'].value_counts() stages = investor_deals_df['Funding Stage'].value_counts() # Display KPIs using st.metric for a professional dashboard feel col1, col2 = st.columns(2) col1.metric(label="Deals Done", value=total_deals) col2.metric(label="Total Capital Deployed (in their deals)", value=format_currency(total_invested)) # Display preferred verticals and stages col1, col2 = st.columns(2) with col1: st.subheader("Preferred Climate Verticals") if not verticals.empty: for vertical, count in verticals.head(5).items(): st.write(f"• **{vertical}**: {count} deals") else: st.write("No data available") with col2: st.subheader("Preferred Funding Stages") if not stages.empty: for stage, count in stages.head(5).items(): st.write(f"• **{stage}**: {count} deals") else: st.write("No data available") # Display all deals table st.subheader("All Deals") st.write(f"📊 **{total_deals} deals found**") # Prepare deals table for display deals_display = investor_deals_df[[ 'Company Name', 'Funding Date', 'Amount', 'Currency', 'Funding Stage', 'Climate Vertical', 'Role', 'Source URL' ]].copy() # Format the Amount column using our helper function deals_display['Amount'] = deals_display['Amount'].apply(format_currency) # Display the deals table st.dataframe( deals_display, use_container_width=True, height=400, column_config={ "Company Name": st.column_config.TextColumn( "Company Name", width="medium" ), "Funding Date": st.column_config.DateColumn( "Funding Date", format="YYYY-MM-DD", width="small" ), "Amount": st.column_config.TextColumn( "Amount", width="medium" ), "Currency": st.column_config.TextColumn( "Currency", width="small" ), "Funding Stage": st.column_config.TextColumn( "Funding Stage", width="medium" ), "Climate Vertical": st.column_config.TextColumn( "Climate Vertical", width="large" ), "Role": st.column_config.TextColumn( "Role", width="small" ), "Source URL": st.column_config.LinkColumn( "Source URL", width="small" ) } ) # Main part of the script if __name__ == "__main__": # Initialize session state if 'selected_investor' not in st.session_state: st.session_state.selected_investor = None # Define the path to the data file data_file_path = "data.json" # Load the data df = load_data(data_file_path) # Check if data was loaded successfully if not df.empty: # Add geography column to the data df = add_geography_column(df) # Add deal size categories df['Deal Size Category'] = df['Amount'].apply(categorize_deal_size) # Create main tabs tab1, tab2 = st.tabs(["Investor Database", "Glossary"]) with tab1: # Check if an investor is selected for profile view if st.session_state.selected_investor: # Display investor profile display_investor_profile(df, st.session_state.selected_investor) else: # Display main investor database # Add main title st.title("🏦 Climate Tech Investor Database") # Company Search Section st.subheader("🔍 Quick Company Search") company_search = st.text_input( "Who funded this company?", placeholder="e.g., PikaCharge, Reneo, Nira Energy...", help="Enter a company name to quickly find their investors" ) # Display company search results if search term is provided if company_search: # Search for the company in the deals data company_matches = df[df['Company Name'].str.contains(company_search, case=False, na=False)] if not company_matches.empty: st.success(f"Found {len(company_matches)} funding round(s) for companies matching '{company_search}':") for idx, deal in company_matches.iterrows(): with st.expander(f"📈 {deal['Company Name']} - {deal['Funding Stage']} ({deal['Funding Date'].strftime('%Y-%m-%d')})"): col1, col2 = st.columns(2) with col1: st.write("**💰 Deal Details:**") st.write(f"• **Amount**: {format_currency(deal['Amount'])} {deal['Currency']}") st.write(f"• **Stage**: {deal['Funding Stage']}") st.write(f"• **Date**: {deal['Funding Date'].strftime('%Y-%m-%d')}") st.write(f"• **Vertical**: {deal['Climate Vertical']}") with col2: st.write("**🏦 Investors:**") if pd.notna(deal['Lead Investor(s)']) and deal['Lead Investor(s)'] != "Not specified": st.write(f"• **Lead Investor(s)**: {deal['Lead Investor(s)']}") if pd.notna(deal['Other Investors']) and deal['Other Investors'] != "Not specified": st.write(f"• **Other Investors**: {deal['Other Investors']}") if pd.notna(deal['Source URL']): st.write(f"🔗 [Source]({deal['Source URL']})") else: st.warning(f"No companies found matching '{company_search}'. Try a different search term or check the spelling.") st.divider() # Visual separator between search and main content # Sidebar filters st.sidebar.header("🎯 Build Your Investor Target List") # Advanced Filters Section st.sidebar.subheader("🎯 Advanced Filters") # Lead Investors Only checkbox - Critical for fundraising founders lead_only = st.sidebar.checkbox( "Lead Investors Only", value=False, help="Show only investors who have led deals - a critical signal of conviction" ) # Geography filter geographies = ["All"] + df['Geography'].unique().tolist() selected_geography = st.sidebar.selectbox( "Geography", options=geographies, index=0, help="Filter investors by geographic focus" ) # Deal Size Buckets - Relevant to funding stages st.sidebar.subheader("💰 Deal Size Focus") deal_size_categories = ["All"] + df['Deal Size Category'].unique().tolist() selected_deal_size = st.sidebar.selectbox( "Deal Size Category", options=deal_size_categories, index=0, help="Filter by deal size buckets relevant to funding stages" ) # Basic Filters Section st.sidebar.subheader("📊 Basic Filters") # Climate Vertical multi-select filter climate_verticals = df['Climate Vertical'].unique().tolist() selected_verticals = st.sidebar.multiselect( "Climate Vertical", options=climate_verticals, default=climate_verticals # Show all by default ) # Funding Stage select box filter funding_stages = ["All"] + df['Funding Stage'].unique().tolist() selected_stage = st.sidebar.selectbox( "Funding Stage", options=funding_stages, index=0 # Default to "All" ) # Investor Name text input filter investor_search = st.sidebar.text_input( "Investor Name", placeholder="e.g., Breakthrough Energy Ventures" ) # Check if any filters have been applied (for contextual welcome message) filters_applied = ( lead_only or # Lead investors only is checked selected_geography != "All" or # Geography filter is not "All" selected_deal_size != "All" or # Deal size filter is not "All" len(selected_verticals) != len(climate_verticals) or # Not all verticals selected selected_stage != "All" or # Funding stage filter is not "All" investor_search.strip() != "" or # Investor name search has text company_search.strip() != "" # Company search has text ) # Display contextual welcome message for new users if not filters_applied: st.info( "👋 **Welcome, Founder!** Start by using the filters on the left to build your ideal investor profile. " "Try filtering by geography, deal size, or climate vertical to find investors that match your startup's needs.", icon="💡" ) # Filter the deals DataFrame first to get relevant investors filtered_deals_df = df.copy() # Apply Geography filter to deals if selected_geography != "All": filtered_deals_df = filtered_deals_df[filtered_deals_df['Geography'] == selected_geography] # Apply Deal Size Category filter to deals if selected_deal_size != "All": filtered_deals_df = filtered_deals_df[filtered_deals_df['Deal Size Category'] == selected_deal_size] # Apply Climate Vertical filter to deals if selected_verticals: filtered_deals_df = filtered_deals_df[filtered_deals_df['Climate Vertical'].isin(selected_verticals)] # Apply Funding Stage filter to deals if selected_stage != "All": filtered_deals_df = filtered_deals_df[filtered_deals_df['Funding Stage'] == selected_stage] # Create filtered investor summary based on filtered deals and lead_only setting if len(filtered_deals_df) > 0: filtered_investor_summary = create_investor_summary(filtered_deals_df, lead_only=lead_only) else: columns = ['Investor Name', 'Deals Done', 'Lead Deals', 'Total Invested', 'Preferred Verticals', 'Preferred Stages'] filtered_investor_summary = pd.DataFrame(columns=columns) # Apply Investor Name filter to investor summary if investor_search: investor_mask = filtered_investor_summary['Investor Name'].str.contains(investor_search, case=False, na=False) filtered_investor_summary = filtered_investor_summary[investor_mask] # KPI Dashboard Section st.subheader("📊 Investor Overview") # Create 3 columns for KPI metrics col1, col2, col3 = st.columns(3) # Calculate KPIs from filtered investor data total_investors = len(filtered_investor_summary) # Safely calculate total funding, handling any infinite or NaN values total_funding_tracked = filtered_investor_summary['Total Invested'].replace([float('inf'), -float('inf')], 0).fillna(0).sum() avg_investment_per_investor = total_funding_tracked / total_investors if total_investors > 0 else 0 # Display KPI metrics with col1: st.metric( label="Active Investors", value=f"{total_investors:,}" ) with col2: st.metric( label="Total Capital Tracked", value=format_currency(total_funding_tracked) ) with col3: st.metric( label="Avg. Investment/Investor", value=format_currency(avg_investment_per_investor) ) # Top Investors Chart st.subheader("Top Investors by Capital") if not filtered_investor_summary.empty: # Get top 10 investors by total invested top_investors_data = filtered_investor_summary.head(10) # Create a DataFrame for the chart with formatted labels chart_data = top_investors_data.set_index('Investor Name')['Total Invested'] # Display the chart st.bar_chart(chart_data) # Add a formatted summary below the chart st.write("**Top 5 Investors:**") for idx, (investor, amount) in enumerate(chart_data.head(5).items(), 1): st.write(f"{idx}. **{investor}**: {format_currency(amount)}") else: st.info("No investors found for the selected filters.") # Add subheader for the investor table st.subheader("Climate Tech Investors") # Display filtered investor info st.write(f"📊 **Showing {len(filtered_investor_summary)} investors**") # Alphabetical navigation bar st.subheader("🔤 Browse by Name") # Define the alphabet cluster groups alphabet_clusters = ["All", "A-C", "D-F", "G-I", "J-L", "M-O", "P-R", "S-U", "V-Z", "#"] # Initialize the selected cluster in session_state if it doesn't exist if 'selected_cluster' not in st.session_state: st.session_state.selected_cluster = "All" # Create a horizontal layout for the navigation buttons using st.columns cols = st.columns(len(alphabet_clusters)) for i, cluster in enumerate(alphabet_clusters): # Highlight the selected cluster with a different style if cluster == st.session_state.selected_cluster: if cols[i].button(f"**{cluster}**", key=f"btn_{cluster}", help=f"Currently showing: {cluster}"): st.session_state.selected_cluster = cluster else: if cols[i].button(cluster, key=f"btn_{cluster}"): st.session_state.selected_cluster = cluster # Filter the investor_summary DataFrame based on the selected cluster selected = st.session_state.selected_cluster if selected != "All": if selected == "#": # Logic for investors not starting with a letter filtered_investors = filtered_investor_summary[~filtered_investor_summary['Investor Name'].str[0].str.isalpha()] else: # Logic for letter-based clusters start_char, end_char = selected.split('-') filtered_investors = filtered_investor_summary[ filtered_investor_summary['Investor Name'].str.upper().str[0].between(start_char, end_char) ] else: # If "All" is selected, use the full (sidebar-filtered) DataFrame filtered_investors = filtered_investor_summary # Update the display count to reflect alphabetical filtering st.write(f"📊 **Showing {len(filtered_investors)} investors** (filtered by: {selected})") # Add view toggle for different display formats view_option = st.radio( "Choose your view:", ["📋 Card View", "📊 Table View"], horizontal=True, help="Card view is better for scanning, table view is better for detailed comparison" ) # Create investor display based on selected view if not filtered_investors.empty: if view_option == "📋 Card View": st.write("💡 **Tip**: Scan the cards below to quickly identify investors that match your criteria:") # Create rich investor cards for idx, row in filtered_investors.iterrows(): investor_name = row['Investor Name'] deals_done = row['Deals Done'] lead_deals = row['Lead Deals'] total_invested = row['Total Invested'] preferred_verticals = row['Preferred Verticals'].split(', ') if row['Preferred Verticals'] else [] preferred_stages = row['Preferred Stages'].split(', ') if row['Preferred Stages'] else [] # Create horizontal rule to separate cards st.markdown("---") # Create card layout with columns col1, col2 = st.columns([3, 1]) with col1: # Investor name as subheader st.subheader(f"🏦 {investor_name}") # Create visual tags for preferred verticals if preferred_verticals and preferred_verticals[0]: st.markdown("**🎯 Top Climate Verticals:**") vertical_tags = " ".join([f"`{vertical.strip()}`" for vertical in preferred_verticals[:3] if vertical.strip()]) st.markdown(vertical_tags) # Create visual tags for preferred stages if preferred_stages and preferred_stages[0]: st.markdown("**📈 Preferred Funding Stages:**") stage_tags = " ".join([f"`{stage.strip()}`" for stage in preferred_stages[:3] if stage.strip()]) st.markdown(stage_tags) with col2: # Key metrics in the right column st.metric("Total Deals", deals_done) st.metric("Lead Deals", lead_deals, help="Deals where they were the lead investor") st.metric("Capital Deployed", format_currency(total_invested)) # View profile button if st.button("👁️ View Profile", key=f"card_btn_{idx}", help="See detailed investor profile"): st.session_state.selected_investor = investor_name st.rerun() else: # Table View st.write("Click on an investor name to view their detailed profile:") # Create buttons for each investor (original format) for idx, row in filtered_investors.iterrows(): investor_name = row['Investor Name'] deals_done = row['Deals Done'] lead_deals = row['Lead Deals'] total_invested = row['Total Invested'] # Format the button label with key info including lead deals button_label = f"👤 {investor_name} | {deals_done} deals ({lead_deals} lead) | {format_currency(total_invested)}" if st.button(button_label, key=f"investor_{idx}"): st.session_state.selected_investor = investor_name st.rerun() # Display interactive table only in Table View if view_option == "📊 Table View": st.subheader("Interactive Investor Table") # Configure pandas display options for better visibility pd.set_option('display.max_columns', None) pd.set_option('display.width', None) pd.set_option('display.max_colwidth', 100) # Use the alphabetically filtered investor DataFrame display_df = filtered_investors.copy() # Format the Total Invested column using our helper function if not display_df.empty: display_df['Total Invested'] = display_df['Total Invested'].apply(format_currency) # Add a 'Select' column with checkboxes for building target list display_df.insert(0, 'Select', False) # Display the investor summary DataFrame with interactive checkboxes st.write("💡 **Tip**: Check the boxes next to investors you want to target, then export your list!") edited_df = st.data_editor( display_df, use_container_width=True, # Use full container width height=400, # Reduced height since we have buttons above column_config={ "Select": st.column_config.CheckboxColumn( "Select", help="Check to add this investor to your target list", width="small" ), "Investor Name": st.column_config.TextColumn( "Investor Name", width="large" ), "Deals Done": st.column_config.NumberColumn( "Deals Done", width="small" ), "Lead Deals": st.column_config.NumberColumn( "Lead Deals", width="small", help="Number of deals where this investor was the lead - key conviction signal" ), "Total Invested": st.column_config.TextColumn( "Total Invested", width="medium" ), "Preferred Verticals": st.column_config.TextColumn( "Preferred Verticals", width="large" ), "Preferred Stages": st.column_config.TextColumn( "Preferred Stages", width="medium" ) }, disabled=["Investor Name", "Deals Done", "Lead Deals", "Total Invested", "Preferred Verticals", "Preferred Stages"], hide_index=True ) # Check which investors were selected and provide export functionality if not edited_df.empty: selected_investors = edited_df[edited_df['Select'] == True] if len(selected_investors) > 0: st.success(f"🎯 **{len(selected_investors)} investors selected for your target list!**") # Prepare the export data (remove the Select column for cleaner export) export_df = selected_investors.drop('Select', axis=1) # Convert DataFrame to CSV csv_data = export_df.to_csv(index=False) # Create download button st.download_button( label="📥 Export Selected Investors to CSV", data=csv_data, file_name=f"target_investors_{len(selected_investors)}_selected.csv", mime="text/csv", help="Download your selected investors as a CSV file for outreach planning" ) # Show a preview of selected investors with st.expander(f"Preview of {len(selected_investors)} Selected Investors"): st.dataframe(export_df, use_container_width=True) else: st.info("💡 Select investors using the checkboxes above to build your target list and export to CSV.") else: st.info("No investors found for the selected filters.") with tab2: # Glossary Tab Content st.header("📚 Key Terminology") st.subheader("Pre-Seed/Seed Round") st.write(""" **Pre-Seed** and **Seed** rounds are the earliest stages of startup funding. Pre-seed typically involves initial capital from founders, friends, and family to validate the business idea. Seed rounds follow, providing funding to develop the product, conduct market research, and build an initial team. These rounds usually range from $50K to $2M. """) st.subheader("Series A, B, C") st.write(""" **Series A, B, C** represent sequential funding rounds as startups grow: - **Series A**: First major institutional funding round (typically $2M-$15M) to scale the product and expand the team - **Series B**: Growth funding (typically $10M-$50M) to expand market reach and accelerate revenue - **Series C**: Later-stage funding (typically $30M+) for market expansion, acquisitions, or preparing for IPO """) st.subheader("Venture Capital (VC)") st.write(""" **Venture Capital (VC)** refers to investment firms that provide funding to high-growth startups in exchange for equity ownership. VCs typically invest in companies with strong growth potential and aim for significant returns through eventual exits (IPO or acquisition). They often provide mentorship and strategic guidance beyond just capital. """) st.subheader("Lead Investor") st.write(""" The **Lead Investor** is the primary investor in a funding round who typically contributes the largest portion of capital and takes the lead in negotiating terms, conducting due diligence, and structuring the deal. They often secure a board seat and play an active role in guiding the company's strategic direction. """) st.subheader("Climate Vertical") st.write(""" **Climate Vertical** refers to specific sectors within the climate technology space, such as renewable energy, carbon capture, sustainable transportation, or green agriculture. Each vertical addresses different aspects of climate change mitigation or adaptation, allowing investors to focus on particular areas of environmental impact. """) else: st.warning("No data to display. Please check your data.json file.") # AI Assistant Feature st.markdown("---") with st.expander("🤖 AI Assistant: Extract New Funding Deal"): st.info("Paste the URL of a funding announcement article below to see the AI in action.", icon="💡") url_input = st.text_input("Article URL") if st.button("Extract Funding Data"): if url_input: with st.spinner("Reading article and calling AI... this may take a moment."): extracted_data = extract_data_with_ai(url_input) # Handle different types of errors if "error" in extracted_data: error_msg = extracted_data["error"] if "quota exceeded" in error_msg.lower(): st.error("🚫 API quota exceeded") st.markdown(""" **To fix this:** 1. Go to [Usage Dashboard](https://platform.openai.com/usage) 2. Check your current usage and limits 3. Add credits at [OpenAI Billing](https://platform.openai.com/account/billing) 4. Or upgrade your plan for higher limits **Note:** The core VACTNFunds features work perfectly without the AI Assistant! """) else: st.error(f"❌ {error_msg}") else: st.subheader("✅ Extracted Data:") st.json(extracted_data) st.success("Extraction complete! This data can be added to the main database in a future version.") else: st.warning("Please enter a URL.") # Add data freshness caption to build trust if not df.empty: last_updated_date = df['Funding Date'].max().strftime("%B %d, %Y") st.caption(f"Data sourced from public announcements. Last updated: {last_updated_date}")