wehub-resource-sync
1336 lines
49 KiB
Python
1336 lines
49 KiB
Python
"""
|
||
Developer Trend & DevRel Ideation Agent
|
||
|
||
Chat-first Streamlit app for developer trend digest and DevRel talk/blog ideation
|
||
from Hacker News, DEV.to, Engram Memory, and an Agno multi-agent team.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import base64
|
||
import hashlib
|
||
import html
|
||
import json
|
||
import logging
|
||
import os
|
||
import re
|
||
import time
|
||
import uuid
|
||
from pathlib import Path
|
||
|
||
import streamlit as st
|
||
|
||
from agents import run_autonomous_content_team
|
||
from chat import (
|
||
apply_prompt_context,
|
||
conversational_response,
|
||
followup_response,
|
||
has_required_context,
|
||
missing_fields,
|
||
render_context_summary,
|
||
wants_brief_run,
|
||
wants_current_report_followup,
|
||
wants_explicit_research_run,
|
||
wants_memory_lookup,
|
||
)
|
||
from config import DEFAULT_MODEL, get_settings, load_project_env
|
||
from engram_memory import MemoryRecord, build_research_summary_preview, create_memory_store
|
||
from llm import build_model, make_agent, parse_json_object, run_agent
|
||
from models import CompanyContext
|
||
|
||
|
||
APP_DIR = Path(__file__).resolve().parent
|
||
load_project_env()
|
||
|
||
CONTEXT_EXTRACTOR_PROMPT = """
|
||
You extract and infer context for a chat-first developer trend and DevRel ideation agent.
|
||
Return only JSON with keys: company_name, product, audience, seed_keywords, competitors, existing_topics.
|
||
|
||
Use the user's natural language and current context. If the user asks for content ideas, talk/blog ideas,
|
||
trend research, or DevRel opportunities for a named product/domain, infer reasonable missing
|
||
product/category, audience, and search angles rather than demanding labels.
|
||
|
||
Do not invent a company if no company, product, or domain is mentioned.
|
||
"""
|
||
|
||
ROUTER_PROMPT = """
|
||
You route messages for a chat-first developer trend and DevRel ideation agent.
|
||
Return only JSON with keys: intent, requires_fresh_sources, reason.
|
||
|
||
Choose one intent:
|
||
- memory_lookup: asks what was discussed, researched, generated, remembered, or done before/in the past/lately, or asks for recommendations based on existing/past research.
|
||
- research_run: asks for fresh/new source research from HN, DEV.to, developer conversations, article supply, trends, topics, or DevRel opportunities.
|
||
- followup: asks about the current/latest report, evidence, summary, or refinements from the current report.
|
||
- chat: asks general questions or gives context without requesting research or memory lookup.
|
||
|
||
Important routing rules:
|
||
- If the user says "based on our research", "last few products", "so far", "what have we researched", or "what should we work on from previous research", choose memory_lookup even if they say suggest/recommend/articles.
|
||
- If the user asks "show evidence for idea 2", "make these more technical", "summarize the report", or "what did we find", choose followup when has_latest_report is true.
|
||
- Choose research_run only when the user wants fresh research, new HN/DEV/source collection, or a new trend digest/report.
|
||
- Do not choose research_run for memory or current-report follow-ups.
|
||
- requires_fresh_sources must be true only when HN/DEV/source APIs should be called now. It must be false for memory_lookup, followup, and chat.
|
||
|
||
Examples:
|
||
- "Based on our research of last few products, what could be the top 3 articles we should work on?" -> {"intent":"memory_lookup","requires_fresh_sources":false,"reason":"Uses existing research across past products."}
|
||
- "What products research have we done so far?" -> {"intent":"memory_lookup","requires_fresh_sources":false,"reason":"Asks about past research."}
|
||
- "Show evidence for idea 2" -> {"intent":"followup","requires_fresh_sources":false,"reason":"Asks about latest report evidence."}
|
||
- "Research HN and DEV and suggest blog ideas for this product" -> {"intent":"research_run","requires_fresh_sources":true,"reason":"Asks for fresh source research."}
|
||
"""
|
||
|
||
MEMORY_SUMMARIZER_PROMPT = """
|
||
You answer questions from Engram memories for a developer trend and DevRel ideation agent.
|
||
Return a concise natural-language answer, not JSON.
|
||
|
||
Rules:
|
||
- Answer the user's question directly.
|
||
- Speak like the app assistant, not like a memory debugger.
|
||
- Do not mention Engram, memory records, "what's known", "what's uncertain", confidence, or retrieval.
|
||
- Use first-person phrasing like "Yes, we have..." or "I don't see that we've...".
|
||
- Do not repeat the same sentence or paragraph.
|
||
- Extract concrete products, companies, trend topics, talk/blog ideas, or reports from memories.
|
||
- Ignore assistant meta chatter like "the user asked", missing-context reminders, or UI status.
|
||
- Ignore irrelevant memories that do not answer the question.
|
||
- Do not call older stored memories "latest", "current", or "recent"; say "previously researched" instead.
|
||
- If memories are noisy or weak, answer briefly and say what you can infer without sounding forensic.
|
||
"""
|
||
|
||
APP_NAME = "Developer Trend & DevRel Ideation Agent"
|
||
APP_WELCOME_VERSION = "devrel-ideation-v2"
|
||
ROUTER_TIMEOUT_SECONDS = 18
|
||
|
||
PIPELINE_STEPS: list[tuple[str, str]] = [
|
||
("planner", "Query Planner"),
|
||
("research_hn", "HN demand research"),
|
||
("research_dev", "DEV.to supply research"),
|
||
("research_engram", "Engram memory lookup"),
|
||
("writer", "DevRel Ideation Writer"),
|
||
("assembly", "Report assembly"),
|
||
]
|
||
|
||
STEP_ICON = {
|
||
"pending": "○",
|
||
"active": "◉",
|
||
"done": "✓",
|
||
"skipped": "–",
|
||
}
|
||
|
||
st.set_page_config(
|
||
page_title=APP_NAME,
|
||
layout="wide",
|
||
initial_sidebar_state="expanded",
|
||
)
|
||
|
||
|
||
def _inline_png(path: Path, height: int) -> str:
|
||
try:
|
||
encoded = base64.b64encode(path.read_bytes()).decode()
|
||
except Exception:
|
||
return ""
|
||
return (
|
||
f"<img src='data:image/png;base64,{encoded}' "
|
||
f"style='height:{height}px; width:auto; display:inline-block; "
|
||
f"vertical-align:middle; margin:0 8px;' alt='{path.stem}'>"
|
||
)
|
||
|
||
|
||
def _png_data_uri(path: Path) -> str:
|
||
try:
|
||
encoded = base64.b64encode(path.read_bytes()).decode()
|
||
except Exception:
|
||
return ""
|
||
return f"data:image/png;base64,{encoded}"
|
||
|
||
|
||
def _inline_svg(path: Path, height: int) -> str:
|
||
try:
|
||
encoded = base64.b64encode(path.read_bytes()).decode()
|
||
except Exception:
|
||
return ""
|
||
return (
|
||
f"<img src='data:image/svg+xml;base64,{encoded}' "
|
||
f"style='height:{height}px; width:auto; display:inline-block; "
|
||
f"vertical-align:middle; margin:0 8px;' alt='{path.stem}'>"
|
||
)
|
||
|
||
|
||
st.markdown(
|
||
"""
|
||
<style>
|
||
.stApp { background: #0B1020; color: #E5E7EB; }
|
||
[data-testid="stAppViewContainer"] .main .block-container {
|
||
max-width: 1580px;
|
||
padding-top: 5.5rem;
|
||
padding-left: 4.25rem;
|
||
padding-right: 4.25rem;
|
||
}
|
||
[data-testid="stSidebar"] {
|
||
background: #111827;
|
||
min-width: 300px;
|
||
max-width: 300px;
|
||
}
|
||
[data-testid="stSidebar"] * {
|
||
font-size: 1rem;
|
||
}
|
||
[data-testid="stSidebar"] h3 {
|
||
font-size: 1.15rem;
|
||
}
|
||
[data-testid="stSidebar"] .stCaptionContainer,
|
||
[data-testid="stSidebar"] .stCaptionContainer p {
|
||
font-size: 0.96rem;
|
||
line-height: 1.45;
|
||
}
|
||
[data-testid="stChatMessage"] {
|
||
background: rgba(31, 41, 55, 0.72);
|
||
border: 1px solid rgba(148, 163, 184, 0.18);
|
||
border-radius: 8px;
|
||
padding: 1rem 1.1rem;
|
||
max-width: 100%;
|
||
}
|
||
[data-testid="stChatMessage"] p,
|
||
[data-testid="stChatMessage"] li {
|
||
font-size: 1.06rem;
|
||
line-height: 1.65;
|
||
}
|
||
[data-testid="stChatMessage"] [data-testid="stMarkdownContainer"] {
|
||
max-width: 980px;
|
||
}
|
||
[data-testid="stCaptionContainer"] p {
|
||
font-size: 1rem;
|
||
line-height: 1.5;
|
||
}
|
||
[data-testid="stChatInput"] textarea {
|
||
font-size: 1.02rem;
|
||
line-height: 1.45;
|
||
}
|
||
.eca-provider-row {
|
||
display: flex;
|
||
align-items: center;
|
||
gap: 8px;
|
||
flex-wrap: wrap;
|
||
margin: 6px 0 4px;
|
||
}
|
||
.eca-provider-pill {
|
||
display: inline-flex;
|
||
align-items: center;
|
||
gap: 6px;
|
||
border: 1px solid rgba(148, 163, 184, 0.28);
|
||
background: rgba(15, 23, 42, 0.76);
|
||
border-radius: 8px;
|
||
padding: 5px 8px;
|
||
font-size: 0.86rem;
|
||
line-height: 1.1;
|
||
}
|
||
.eca-title {
|
||
display: flex;
|
||
align-items: center;
|
||
flex-wrap: wrap;
|
||
gap: 14px;
|
||
margin: 0;
|
||
padding: 0;
|
||
font-size: 2.65rem;
|
||
font-weight: 800;
|
||
color: #F9FAFB;
|
||
line-height: 1.15;
|
||
}
|
||
.eca-source-chip {
|
||
display: inline-flex;
|
||
align-items: center;
|
||
gap: 8px;
|
||
white-space: nowrap;
|
||
}
|
||
.eca-source-chip img {
|
||
height: 40px;
|
||
width: auto;
|
||
display: inline-block;
|
||
}
|
||
.eca-brand-card {
|
||
width: 100%;
|
||
height: 70px;
|
||
border-radius: 8px;
|
||
background: #FFFFFF;
|
||
border: 1px solid rgba(255, 255, 255, 0.18);
|
||
padding: 10px 14px;
|
||
box-shadow: 0 8px 18px rgba(0, 0, 0, 0.18);
|
||
display: flex;
|
||
align-items: center;
|
||
justify-content: center;
|
||
margin: 8px 0 10px;
|
||
}
|
||
.eca-brand-card img {
|
||
display: block;
|
||
height: 42px;
|
||
width: 175px;
|
||
object-fit: contain;
|
||
}
|
||
.eca-metric-row {
|
||
display: flex;
|
||
gap: 10px;
|
||
flex-wrap: wrap;
|
||
margin: 6px 0 12px;
|
||
}
|
||
.eca-metric {
|
||
display: inline-flex;
|
||
align-items: center;
|
||
border: 1px solid rgba(148, 163, 184, 0.24);
|
||
border-radius: 8px;
|
||
background: rgba(15, 23, 42, 0.7);
|
||
padding: 5px 9px;
|
||
font-size: 0.92rem;
|
||
}
|
||
.eca-section-note {
|
||
color: #AEB7C7;
|
||
font-size: 0.98rem;
|
||
line-height: 1.45;
|
||
margin: 0.1rem 0 1rem;
|
||
}
|
||
@media (max-width: 900px) {
|
||
[data-testid="stAppViewContainer"] .main .block-container {
|
||
padding-left: 1rem;
|
||
padding-right: 1rem;
|
||
}
|
||
.eca-title {
|
||
font-size: 2rem;
|
||
}
|
||
.eca-source-chip img {
|
||
height: 32px;
|
||
}
|
||
}
|
||
</style>
|
||
""",
|
||
unsafe_allow_html=True,
|
||
)
|
||
|
||
hackernews_img_inline = _inline_svg(APP_DIR / "assets" / "hacker_news.svg", 40)
|
||
devto_img_inline = _inline_svg(APP_DIR / "assets" / "devto.svg", 40)
|
||
title_html = f"""
|
||
<div style='display:flex; align-items:center; width:100%; padding:8px 0;'>
|
||
<h1 class='eca-title'>
|
||
<span>{APP_NAME} with</span>
|
||
<span class='eca-source-chip'>{hackernews_img_inline}<span>Hacker News</span></span>
|
||
<span>and</span>
|
||
<span class='eca-source-chip'>{devto_img_inline}<span>DEV.to</span></span>
|
||
</h1>
|
||
</div>
|
||
"""
|
||
st.markdown(title_html, unsafe_allow_html=True)
|
||
st.caption(
|
||
"Agno multi-agent research from Hacker News trends, DEV.to supply gaps, "
|
||
"Engram memory, and GLM report writing."
|
||
)
|
||
|
||
|
||
def init_state() -> None:
|
||
settings = get_settings(require_nebius=False)
|
||
defaults = {
|
||
"messages": [],
|
||
"context": {
|
||
"company_name": "",
|
||
"product": "",
|
||
"audience": "",
|
||
"seed_keywords": [],
|
||
"competitors": [],
|
||
"existing_topics": [],
|
||
},
|
||
"limit": 8,
|
||
"latest_result": None,
|
||
"stage_messages": [],
|
||
"pipeline_steps": {step_id: "pending" for step_id, _ in PIPELINE_STEPS},
|
||
"memory_store": None,
|
||
"is_running": False,
|
||
"conversation_id": f"eca-{uuid.uuid4().hex[:10]}",
|
||
"engram_user_id": settings.engram_user_id,
|
||
"stored_context_fingerprint": "",
|
||
"welcome_version": APP_WELCOME_VERSION,
|
||
}
|
||
for key, value in defaults.items():
|
||
if key not in st.session_state:
|
||
st.session_state[key] = value
|
||
st.session_state.engram_user_id = settings.engram_user_id
|
||
|
||
if st.session_state.get("welcome_version") != APP_WELCOME_VERSION:
|
||
st.session_state.messages = []
|
||
st.session_state.latest_result = None
|
||
st.session_state.welcome_version = APP_WELCOME_VERSION
|
||
|
||
|
||
def reset_pipeline_steps() -> None:
|
||
st.session_state.pipeline_steps = {step_id: "pending" for step_id, _ in PIPELINE_STEPS}
|
||
|
||
|
||
def update_pipeline_from_message(message: str) -> None:
|
||
lowered = message.lower()
|
||
steps = st.session_state.pipeline_steps
|
||
|
||
def activate(step_id: str) -> None:
|
||
for sid, _ in PIPELINE_STEPS:
|
||
if sid == step_id:
|
||
steps[sid] = "active"
|
||
elif steps.get(sid) == "active":
|
||
steps[sid] = "done"
|
||
|
||
def complete(step_id: str) -> None:
|
||
steps[step_id] = "done"
|
||
|
||
if "query planner" in lowered:
|
||
activate("planner")
|
||
if "selected hn" in lowered:
|
||
complete("planner")
|
||
if "hn demand" in lowered or "search_hacker_news" in lowered or "hn fallback" in lowered or "completing hn" in lowered:
|
||
activate("research_hn")
|
||
if "returned" in lowered or "collected" in lowered or "finished search_hacker_news" in lowered:
|
||
complete("research_hn")
|
||
if "dev supply" in lowered or "search_dev_to" in lowered or "dev.to fallback" in lowered or "completing dev" in lowered:
|
||
activate("research_dev")
|
||
if "returned" in lowered or "collected" in lowered or "finished search_dev_to" in lowered:
|
||
complete("research_dev")
|
||
if "engram memory" in lowered:
|
||
activate("research_engram")
|
||
if "returned" in lowered or "found" in lowered or "no prior memories" in lowered:
|
||
complete("research_engram")
|
||
if "devrel ideation writer" in lowered or "ideation writer" in lowered:
|
||
activate("writer")
|
||
if "producing the report" in lowered:
|
||
complete("writer")
|
||
if "assembling report" in lowered or "storing research summary" in lowered or "research complete" in lowered:
|
||
activate("assembly")
|
||
complete("assembly")
|
||
complete("planner")
|
||
complete("writer")
|
||
|
||
|
||
def render_pipeline_stepper() -> str:
|
||
lines = ["**Pipeline**"]
|
||
for step_id, label in PIPELINE_STEPS:
|
||
state = st.session_state.pipeline_steps.get(step_id, "pending")
|
||
lines.append(f"{STEP_ICON.get(state, '○')} {label}")
|
||
return "\n".join(lines)
|
||
|
||
|
||
def truncate_judge_note(note: str, limit: int = 320) -> str:
|
||
cleaned = " ".join(note.split())
|
||
if len(cleaned) <= limit:
|
||
return cleaned
|
||
return cleaned[: limit - 3].rstrip() + "..."
|
||
|
||
|
||
def assistant_prompt_for_missing() -> str:
|
||
missing = missing_fields(st.session_state.context)
|
||
if not missing:
|
||
return (
|
||
"I’ve got enough to work with. Ask me to find content ideas or a trend digest, and I’ll run the Agno team to "
|
||
"research HN and DEV in parallel, check Engram memory, and return ranked trends plus talk/blog ideas."
|
||
)
|
||
if len(missing) == 1:
|
||
return f"One thing I still need before I can run it: {missing[0]}."
|
||
return "I’m close. I still need " + ", ".join(missing[:-1]) + f", and {missing[-1]}."
|
||
|
||
|
||
def persist_session_env(values: dict[str, str]) -> None:
|
||
env_path = APP_DIR / ".env"
|
||
existing: dict[str, str] = {}
|
||
if env_path.exists():
|
||
for raw_line in env_path.read_text(encoding="utf-8").splitlines():
|
||
if "=" not in raw_line or raw_line.strip().startswith("#"):
|
||
continue
|
||
key, value = raw_line.split("=", 1)
|
||
existing[key] = value
|
||
existing.update({key: value for key, value in values.items() if value})
|
||
lines = [f"{key}={value}" for key, value in existing.items()]
|
||
env_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
|
||
|
||
|
||
async def run_brief(
|
||
context: CompanyContext,
|
||
limit: int,
|
||
on_progress=None,
|
||
):
|
||
settings = get_settings(require_nebius=True)
|
||
if st.session_state.memory_store is None:
|
||
st.session_state.memory_store = create_memory_store(
|
||
settings.engram_api_key,
|
||
settings.engram_namespace,
|
||
settings.engram_conversation_id,
|
||
)
|
||
|
||
def on_stage(message: str) -> None:
|
||
st.session_state.stage_messages.append(message)
|
||
update_pipeline_from_message(message)
|
||
if on_progress is not None:
|
||
on_progress(message)
|
||
|
||
return await run_autonomous_content_team(
|
||
context=context,
|
||
settings=settings,
|
||
memory_store=st.session_state.memory_store,
|
||
limit=limit,
|
||
on_stage=on_stage,
|
||
engram_user_id=st.session_state.engram_user_id,
|
||
conversation_id=settings.engram_conversation_id or st.session_state.conversation_id,
|
||
)
|
||
|
||
|
||
def render_progress_log(messages: list[str], max_lines: int = 14) -> str:
|
||
recent = messages[-max_lines:]
|
||
return "\n".join(f"- {message}" for message in recent)
|
||
|
||
|
||
def _merge_context_update(update: dict) -> bool:
|
||
changed = False
|
||
for field in (
|
||
"company_name",
|
||
"product",
|
||
"audience",
|
||
"seed_keywords",
|
||
"competitors",
|
||
"existing_topics",
|
||
):
|
||
value = update.get(field)
|
||
if value in (None, "", []):
|
||
continue
|
||
if field in {"seed_keywords", "competitors", "existing_topics"}:
|
||
if isinstance(value, str):
|
||
items = [item.strip() for item in value.split(",") if item.strip()]
|
||
elif isinstance(value, list):
|
||
items = [str(item).strip() for item in value if str(item).strip()]
|
||
else:
|
||
items = [str(value).strip()]
|
||
if items and not st.session_state.context[field]:
|
||
st.session_state.context[field] = items[:10]
|
||
changed = True
|
||
elif not st.session_state.context[field].strip():
|
||
st.session_state.context[field] = str(value).strip()
|
||
changed = True
|
||
return changed
|
||
|
||
|
||
async def enrich_context_with_llm(prompt: str) -> bool:
|
||
settings = get_settings(require_nebius=False)
|
||
if not settings.nebius_api_key:
|
||
return False
|
||
model = build_model(settings)
|
||
agent = make_agent(model, CONTEXT_EXTRACTOR_PROMPT, "context_extractor")
|
||
request = {
|
||
"user_message": prompt,
|
||
"current_context": st.session_state.context,
|
||
"recent_chat": st.session_state.messages[-6:],
|
||
}
|
||
try:
|
||
payload = parse_json_object(await run_agent(agent, json.dumps(request, ensure_ascii=False)))
|
||
except Exception:
|
||
return False
|
||
return _merge_context_update(payload)
|
||
|
||
|
||
async def route_prompt_with_llm(prompt: str) -> str:
|
||
settings = get_settings(require_nebius=False)
|
||
fallback_intent = "chat"
|
||
if wants_current_report_followup(prompt) and st.session_state.latest_result is not None:
|
||
fallback_intent = "followup"
|
||
elif wants_memory_lookup(prompt):
|
||
fallback_intent = "memory_lookup"
|
||
elif wants_brief_run(prompt, st.session_state.context):
|
||
fallback_intent = "research_run"
|
||
elif st.session_state.latest_result is not None:
|
||
fallback_intent = "followup"
|
||
|
||
if not settings.nebius_api_key:
|
||
return fallback_intent
|
||
|
||
model = build_model(settings)
|
||
agent = make_agent(model, ROUTER_PROMPT, "message_router")
|
||
request = {
|
||
"user_message": prompt,
|
||
"current_context": st.session_state.context,
|
||
"has_latest_report": st.session_state.latest_result is not None,
|
||
"missing_required_context": missing_fields(st.session_state.context),
|
||
"recent_chat": st.session_state.messages[-6:],
|
||
}
|
||
try:
|
||
payload = parse_json_object(
|
||
await asyncio.wait_for(
|
||
run_agent(agent, json.dumps(request, ensure_ascii=False)),
|
||
timeout=ROUTER_TIMEOUT_SECONDS,
|
||
)
|
||
)
|
||
except Exception:
|
||
return fallback_intent
|
||
|
||
intent = str(payload.get("intent", "")).strip().lower()
|
||
requires_fresh_sources = payload.get("requires_fresh_sources")
|
||
if intent == "research_run" and requires_fresh_sources is False:
|
||
return fallback_intent if fallback_intent != "chat" else "memory_lookup"
|
||
if intent in {"memory_lookup", "research_run", "followup", "chat"}:
|
||
return intent
|
||
return fallback_intent
|
||
|
||
|
||
async def store_product_context_memory(context: CompanyContext) -> list[str]:
|
||
fingerprint = product_context_fingerprint(context)
|
||
if fingerprint == st.session_state.get("stored_context_fingerprint", ""):
|
||
return []
|
||
if st.session_state.memory_store is None:
|
||
settings = get_settings(require_nebius=False)
|
||
st.session_state.memory_store = create_memory_store(
|
||
settings.engram_api_key,
|
||
settings.engram_namespace,
|
||
settings.engram_conversation_id,
|
||
)
|
||
notes = await st.session_state.memory_store.store_product_context(
|
||
context=context,
|
||
user_id=st.session_state.engram_user_id,
|
||
)
|
||
if any(note.startswith("Stored product context") for note in notes):
|
||
st.session_state.stored_context_fingerprint = fingerprint
|
||
return notes
|
||
|
||
|
||
def product_context_fingerprint(context: CompanyContext) -> str:
|
||
payload = {
|
||
"company_name": context.company_name,
|
||
"product": context.product,
|
||
"audience": context.audience,
|
||
"seed_keywords": context.seed_keywords,
|
||
"competitors": context.competitors,
|
||
"existing_topics": context.existing_topics,
|
||
}
|
||
serialized = json.dumps(payload, sort_keys=True, ensure_ascii=False)
|
||
return hashlib.sha256(serialized.encode("utf-8")).hexdigest()
|
||
|
||
|
||
async def search_memory_answer(prompt: str) -> str:
|
||
settings = get_settings(require_nebius=False)
|
||
if st.session_state.memory_store is None:
|
||
st.session_state.memory_store = create_memory_store(
|
||
settings.engram_api_key,
|
||
settings.engram_namespace,
|
||
settings.engram_conversation_id,
|
||
)
|
||
search_queries = _memory_lookup_queries(prompt)
|
||
search_results = await asyncio.gather(
|
||
*[
|
||
st.session_state.memory_store.search(
|
||
query=query,
|
||
user_id=st.session_state.engram_user_id,
|
||
limit=8 if index == 0 else 4,
|
||
)
|
||
for index, query in enumerate(search_queries)
|
||
]
|
||
)
|
||
memories = _merge_memory_records(search_results)
|
||
if not memories:
|
||
return current_research_context_answer(prompt) or "I don’t see prior useful research for that yet."
|
||
|
||
cleaned_memories = [
|
||
" ".join(memory.content.split())
|
||
for memory in memories[:8]
|
||
if _memory_content_is_useful(memory.content)
|
||
]
|
||
if not cleaned_memories:
|
||
return current_research_context_answer(prompt) or "I don’t see that we’ve researched a concrete product or topic for that yet."
|
||
|
||
if settings.nebius_api_key:
|
||
model = build_model(settings)
|
||
agent = make_agent(model, MEMORY_SUMMARIZER_PROMPT, "memory_summarizer")
|
||
request = {
|
||
"user_question": prompt,
|
||
"memories": cleaned_memories,
|
||
}
|
||
try:
|
||
answer = await run_agent(agent, json.dumps(request, ensure_ascii=False))
|
||
cleaned = answer.strip()
|
||
if cleaned and "unknown model error" not in cleaned.lower():
|
||
memory_answer = _clean_memory_answer(cleaned)
|
||
current_answer = current_research_context_answer(prompt)
|
||
if current_answer and current_answer.lower() not in memory_answer.lower():
|
||
memory_answer = _remove_current_context_conflicts(memory_answer)
|
||
return f"{current_answer}\n\nFrom older stored context: {memory_answer}"
|
||
return memory_answer
|
||
except Exception as exc:
|
||
logging.warning("Memory summarizer LLM call failed: %s", exc)
|
||
|
||
first = cleaned_memories[0][:240]
|
||
current_answer = current_research_context_answer(prompt)
|
||
if current_answer:
|
||
return f"{current_answer}\n\nFrom older stored context, the clearest thing I found is: {first}"
|
||
return f"Yes, we have some previous context. The clearest thing I found is: {first}"
|
||
|
||
|
||
MEMORY_QUERY_STOPWORDS = {
|
||
"what",
|
||
"which",
|
||
"have",
|
||
"has",
|
||
"were",
|
||
"was",
|
||
"we",
|
||
"you",
|
||
"researched",
|
||
"research",
|
||
"before",
|
||
"past",
|
||
"previously",
|
||
"previous",
|
||
"recently",
|
||
"lately",
|
||
"include",
|
||
"available",
|
||
"products",
|
||
"product",
|
||
"topics",
|
||
"topic",
|
||
"ideas",
|
||
"idea",
|
||
"reports",
|
||
"report",
|
||
"and",
|
||
"or",
|
||
"if",
|
||
"the",
|
||
"for",
|
||
"about",
|
||
"related",
|
||
}
|
||
|
||
|
||
def _extract_memory_product_hints(prompt: str) -> list[str]:
|
||
hints: list[str] = []
|
||
for match in re.finditer(r"\b[a-zA-Z0-9][a-zA-Z0-9._-]{1,32}\b", prompt):
|
||
token = match.group(0).strip(".,?!:;()[]{}")
|
||
lowered = token.lower()
|
||
if lowered in MEMORY_QUERY_STOPWORDS:
|
||
continue
|
||
if len(token) < 3 and not any(char.isdigit() for char in token):
|
||
continue
|
||
looks_product_like = (
|
||
any(char.isdigit() for char in token)
|
||
or "." in token
|
||
or "-" in token
|
||
or token[:1].isupper()
|
||
)
|
||
if looks_product_like and lowered not in {item.lower() for item in hints}:
|
||
hints.append(token)
|
||
return hints[:5]
|
||
|
||
|
||
def _memory_lookup_queries(prompt: str) -> list[str]:
|
||
queries = [prompt]
|
||
for hint in _extract_memory_product_hints(prompt):
|
||
queries.extend(
|
||
[
|
||
f"Research summary for {hint}",
|
||
f"Product context for {hint}",
|
||
hint,
|
||
]
|
||
)
|
||
deduped: list[str] = []
|
||
seen: set[str] = set()
|
||
for query in queries:
|
||
normalized = " ".join(query.split()).lower()
|
||
if not normalized or normalized in seen:
|
||
continue
|
||
seen.add(normalized)
|
||
deduped.append(query)
|
||
return deduped[:12]
|
||
|
||
|
||
def _merge_memory_records(search_results: list[list[MemoryRecord]]) -> list[MemoryRecord]:
|
||
merged: list[MemoryRecord] = []
|
||
seen: set[str] = set()
|
||
for result_set in search_results:
|
||
for memory in result_set:
|
||
normalized = " ".join(memory.content.split()).lower()
|
||
if not normalized or normalized in seen:
|
||
continue
|
||
seen.add(normalized)
|
||
merged.append(memory)
|
||
return merged
|
||
|
||
|
||
def current_research_context_answer(prompt: str) -> str | None:
|
||
result = st.session_state.get("latest_result")
|
||
if result is None:
|
||
return None
|
||
lowered = prompt.lower()
|
||
if not any(term in lowered for term in ("product", "topic", "idea", "report", "researched", "suggested")):
|
||
return None
|
||
context = result.context
|
||
company = context.company_name or result.report.company or context.product
|
||
product = context.product or company
|
||
if not company and not product:
|
||
return None
|
||
ideas = ", ".join(idea.title for idea in result.report.content_ideas[:3])
|
||
if ideas:
|
||
return f"In this session, we researched {company or product} ({product}) and suggested ideas like {ideas}."
|
||
return f"In this session, we researched {company or product} ({product})."
|
||
|
||
|
||
def _clean_memory_answer(answer: str) -> str:
|
||
cleaned = answer.strip()
|
||
cleaned = cleaned.replace("Engram Memory", "prior research")
|
||
cleaned = cleaned.replace("Engram memory", "prior research")
|
||
cleaned = cleaned.replace("Engram", "prior research")
|
||
cleaned = cleaned.replace("our latest one", "previously researched")
|
||
cleaned = cleaned.replace("the latest one", "previously researched")
|
||
cleaned = cleaned.replace("latest one", "previously researched")
|
||
paragraphs: list[str] = []
|
||
seen: set[str] = set()
|
||
for paragraph in cleaned.split("\n\n"):
|
||
normalized = " ".join(paragraph.split()).lower()
|
||
if not normalized or normalized in seen:
|
||
continue
|
||
seen.add(normalized)
|
||
paragraphs.append(paragraph.strip())
|
||
return "\n\n".join(paragraphs).strip()
|
||
|
||
|
||
def _remove_current_context_conflicts(answer: str) -> str:
|
||
result = st.session_state.get("latest_result")
|
||
if result is None:
|
||
return answer
|
||
context = result.context
|
||
terms = [
|
||
context.company_name,
|
||
context.product.split(",", 1)[0],
|
||
result.report.company,
|
||
]
|
||
for name in (context.company_name, result.report.company):
|
||
first_word = (name or "").strip().split(" ", 1)[0]
|
||
if len(first_word) > 2:
|
||
terms.append(first_word)
|
||
terms = [term.lower().strip() for term in terms if term and len(term.strip()) > 2]
|
||
if not terms:
|
||
return answer
|
||
|
||
stale_markers = (
|
||
"don't see",
|
||
"do not see",
|
||
"haven't researched",
|
||
"have not researched",
|
||
"not researched",
|
||
"no evidence",
|
||
"not yet",
|
||
)
|
||
pieces = re.split(r"(?<=[.!?])\s+", answer)
|
||
filtered = [
|
||
piece
|
||
for piece in pieces
|
||
if not (
|
||
any(term in piece.lower() for term in terms)
|
||
and any(marker in piece.lower() for marker in stale_markers)
|
||
)
|
||
]
|
||
return " ".join(piece.strip() for piece in filtered if piece.strip()).strip()
|
||
|
||
|
||
def _memory_content_is_useful(content: str) -> bool:
|
||
lowered = content.lower()
|
||
noisy_patterns = (
|
||
"i still need",
|
||
"the user asked",
|
||
"user requested assistance",
|
||
"ask me to find",
|
||
"researching recent",
|
||
"generated the report below",
|
||
"engram memory queued",
|
||
"quality judge",
|
||
"detailed reasoning",
|
||
"publishing briefs",
|
||
"publishing opportunities",
|
||
"seo pages",
|
||
"seo gap",
|
||
"technical seo",
|
||
)
|
||
if any(pattern in lowered for pattern in noisy_patterns):
|
||
return False
|
||
useful_patterns = (
|
||
"product context for",
|
||
"research summary for",
|
||
"top developer trends",
|
||
"top talk/blog ideas",
|
||
"key demand and supply gaps",
|
||
"product/category",
|
||
"seed keywords",
|
||
"audience",
|
||
)
|
||
return any(pattern in lowered for pattern in useful_patterns)
|
||
|
||
|
||
def source_title_lookup(result) -> dict[str, str]:
|
||
lookup: dict[str, str] = {}
|
||
for item in result.hn_items:
|
||
if item.url and item.title:
|
||
lookup[item.url] = item.title
|
||
for article in result.dev_articles:
|
||
if article.url and article.title:
|
||
lookup[article.url] = article.title
|
||
return lookup
|
||
|
||
|
||
def markdown_source_links(
|
||
urls: list[str],
|
||
lookup: dict[str, str],
|
||
empty_text: str,
|
||
limit: int = 4,
|
||
) -> str:
|
||
if not urls:
|
||
return f"- {empty_text}"
|
||
lines = []
|
||
for url in urls[:limit]:
|
||
title = lookup.get(url, url)
|
||
safe_title = title.replace("[", "(").replace("]", ")")
|
||
lines.append(f"- [{safe_title}]({url})" if title != url else f"- {url}")
|
||
return "\n".join(lines)
|
||
|
||
|
||
def render_metric_row(items: list[tuple[str, str | int]]) -> None:
|
||
chips = "".join(
|
||
f"<span class='eca-metric'><strong>{html.escape(str(label))}:</strong> {html.escape(str(value))}</span>"
|
||
for label, value in items
|
||
)
|
||
st.markdown(f"<div class='eca-metric-row'>{chips}</div>", unsafe_allow_html=True)
|
||
|
||
|
||
def render_structured_report(result) -> None:
|
||
lookup = source_title_lookup(result)
|
||
report = result.report
|
||
|
||
st.subheader("What to publish next")
|
||
st.markdown(f"<p class='eca-section-note'>{html.escape(report.summary)}</p>", unsafe_allow_html=True)
|
||
for index, idea in enumerate(report.content_ideas, 1):
|
||
with st.container(border=True):
|
||
st.markdown(f"### {index}. {idea.title}")
|
||
render_metric_row(
|
||
[
|
||
("Score", idea.score),
|
||
("Format", idea.format),
|
||
("Confidence", idea.confidence),
|
||
]
|
||
)
|
||
st.markdown(f"**Audience fit:** {idea.angle}")
|
||
st.markdown(f"**DEV supply gap:** {idea.dev_gap}")
|
||
col_hn, col_dev = st.columns(2)
|
||
with col_hn:
|
||
st.markdown("**HN demand**")
|
||
st.markdown(
|
||
markdown_source_links(
|
||
idea.hn_evidence,
|
||
lookup,
|
||
"No strong HN evidence found in this run.",
|
||
)
|
||
)
|
||
with col_dev:
|
||
st.markdown("**DEV.to supply**")
|
||
st.markdown(
|
||
markdown_source_links(
|
||
idea.dev_links,
|
||
lookup,
|
||
"No specific DEV.to article matched this idea closely.",
|
||
)
|
||
)
|
||
if idea.outline:
|
||
st.markdown("**Suggested outline**")
|
||
st.markdown("\n".join(f"- {item}" for item in idea.outline[:6]))
|
||
|
||
st.subheader("Trend digest")
|
||
for index, trend in enumerate(report.trend_digest, 1):
|
||
with st.expander(f"{index}. {trend.topic} · intensity {trend.intensity_score}"):
|
||
st.markdown(trend.why_trending)
|
||
st.markdown(f"**DEV saturation:** {trend.dev_saturation}")
|
||
col_hn, col_dev = st.columns(2)
|
||
with col_hn:
|
||
st.markdown("**HN links**")
|
||
st.markdown(
|
||
markdown_source_links(
|
||
trend.hn_links,
|
||
lookup,
|
||
"No strong HN evidence found in this run.",
|
||
)
|
||
)
|
||
with col_dev:
|
||
st.markdown("**DEV.to links**")
|
||
st.markdown(
|
||
markdown_source_links(
|
||
trend.dev_links,
|
||
lookup,
|
||
"No specific DEV.to article matched this trend closely.",
|
||
)
|
||
)
|
||
|
||
|
||
def render_grouped_evidence(result) -> None:
|
||
lookup = source_title_lookup(result)
|
||
st.markdown("Grouped by recommendation, so evidence can be checked against the exact idea it supports.")
|
||
for index, idea in enumerate(result.report.content_ideas, 1):
|
||
with st.expander(f"Idea {index}: {idea.title}", expanded=index == 1):
|
||
col_hn, col_dev = st.columns(2)
|
||
with col_hn:
|
||
st.markdown("**HN demand evidence**")
|
||
st.markdown(
|
||
markdown_source_links(
|
||
idea.hn_evidence,
|
||
lookup,
|
||
"No strong HN evidence found in this run.",
|
||
)
|
||
)
|
||
with col_dev:
|
||
st.markdown("**DEV.to supply check**")
|
||
st.markdown(
|
||
markdown_source_links(
|
||
idea.dev_links,
|
||
lookup,
|
||
"No specific DEV.to article matched this idea closely.",
|
||
)
|
||
)
|
||
st.caption(idea.dev_gap)
|
||
|
||
with st.expander("All collected HN items"):
|
||
for item in result.hn_items:
|
||
meta = " · ".join(
|
||
part
|
||
for part in [
|
||
item.created_at,
|
||
f"{item.points} points" if item.points is not None else "",
|
||
f"{item.num_comments} comments" if item.num_comments is not None else "",
|
||
]
|
||
if part
|
||
)
|
||
st.markdown(f"- [{item.title}]({item.url})" + (f" — {meta}" if meta else ""))
|
||
with st.expander("All collected DEV.to articles"):
|
||
for article in result.dev_articles:
|
||
meta = " · ".join(
|
||
part
|
||
for part in [
|
||
article.published_at,
|
||
", ".join(article.tags[:4]) if article.tags else "",
|
||
]
|
||
if part
|
||
)
|
||
st.markdown(f"- [{article.title}]({article.url})" + (f" — {meta}" if meta else ""))
|
||
if article.body_excerpt:
|
||
st.caption(article.body_excerpt[:220])
|
||
|
||
|
||
init_state()
|
||
|
||
with st.sidebar:
|
||
st.subheader("Credentials")
|
||
st.markdown(
|
||
f"""
|
||
<div class="eca-brand-card">
|
||
<img class="eca-sidebar-logo" src="{_png_data_uri(APP_DIR / "assets" / "Nebius.png")}" alt="Nebius" style="width:175px;height:42px;object-fit:contain;">
|
||
</div>
|
||
""",
|
||
unsafe_allow_html=True,
|
||
)
|
||
load_project_env()
|
||
nebius_key = st.text_input(
|
||
"Nebius API Key",
|
||
value=os.getenv("NEBIUS_API_KEY", ""),
|
||
type="password",
|
||
help="Required for Agno agents via Nebius Token Factory.",
|
||
)
|
||
st.markdown(
|
||
f"""
|
||
<div class="eca-brand-card">
|
||
<img class="eca-sidebar-logo" src="{_png_data_uri(APP_DIR / "assets" / "Weaviate_long.png")}" alt="Weaviate" style="width:175px;height:42px;object-fit:contain;">
|
||
</div>
|
||
""",
|
||
unsafe_allow_html=True,
|
||
)
|
||
engram_key = st.text_input(
|
||
"Engram API Key",
|
||
value=os.getenv("ENGRAM_API_KEY", ""),
|
||
type="password",
|
||
help="Optional. Enables persistent Weaviate Engram Memory.",
|
||
)
|
||
if st.button("Save API Keys", use_container_width=True):
|
||
if nebius_key:
|
||
os.environ["NEBIUS_API_KEY"] = nebius_key
|
||
if engram_key:
|
||
os.environ["ENGRAM_API_KEY"] = engram_key
|
||
persist_session_env(
|
||
{
|
||
"NEBIUS_API_KEY": nebius_key,
|
||
"NEBIUS_MODEL": os.getenv("NEBIUS_MODEL", DEFAULT_MODEL),
|
||
"ENGRAM_API_KEY": engram_key,
|
||
}
|
||
)
|
||
st.session_state.memory_store = None
|
||
st.success("Saved for this session.")
|
||
|
||
st.caption(f"Model: {os.getenv('NEBIUS_MODEL', DEFAULT_MODEL)}")
|
||
st.caption("LLM API: Nebius Token Factory")
|
||
st.caption("HN: no key")
|
||
st.caption("DEV: public API")
|
||
st.caption("Nebius detected" if os.getenv("NEBIUS_API_KEY") else "Nebius key missing")
|
||
st.caption(
|
||
"Engram Memory enabled"
|
||
if os.getenv("ENGRAM_API_KEY")
|
||
else "Engram missing; memory disabled"
|
||
)
|
||
|
||
if not st.session_state.messages:
|
||
welcome = (
|
||
"Tell me about your product and audience, then ask for a **trend digest** and **talk/blog ideas**. "
|
||
"The Agno agents will choose searches, gather Hacker News demand, DEV.to supply gaps, and Engram memory, then write a grounded report.\n\n"
|
||
"Example:\n\n"
|
||
"*I run raah.dev, a web analytics and network observability tool. My audience is backend engineers "
|
||
"who care about latency, error rates, and user-side ISP behavior. "
|
||
"Research what developers are discussing on HN, check DEV.to saturation, and suggest talk and blog ideas "
|
||
"around debugging production services.*\n\n"
|
||
"Follow-ups you can try after a report: *What did we find?* or *Show evidence for idea 1*."
|
||
)
|
||
st.session_state.messages.append({"role": "assistant", "content": welcome})
|
||
|
||
for message in st.session_state.messages:
|
||
with st.chat_message(message["role"]):
|
||
st.markdown(message["content"])
|
||
|
||
chat_placeholder = (
|
||
"Research is running. Please wait for the current report..."
|
||
if st.session_state.is_running
|
||
else "Describe your product… or ask for a trend digest and talk/blog ideas…"
|
||
)
|
||
prompt = st.chat_input(chat_placeholder, disabled=st.session_state.is_running)
|
||
if prompt:
|
||
st.session_state.messages.append({"role": "user", "content": prompt})
|
||
with st.chat_message("user"):
|
||
st.markdown(prompt)
|
||
|
||
if st.session_state.is_running:
|
||
response = "I’m still running the current report. I’ll be ready for follow-up questions as soon as it finishes."
|
||
with st.chat_message("assistant"):
|
||
st.markdown(response)
|
||
st.session_state.messages.append({"role": "assistant", "content": response})
|
||
st.stop()
|
||
|
||
parsed_context = apply_prompt_context(prompt, st.session_state.context)
|
||
try:
|
||
prompt_intent = asyncio.run(route_prompt_with_llm(prompt))
|
||
if prompt_intent == "followup" and st.session_state.latest_result is None:
|
||
prompt_intent = "no_report_followup"
|
||
except Exception:
|
||
prompt_intent = (
|
||
"research_run"
|
||
if wants_explicit_research_run(prompt)
|
||
else
|
||
"followup"
|
||
if wants_current_report_followup(prompt) and st.session_state.latest_result is not None
|
||
else
|
||
"no_report_followup"
|
||
if wants_current_report_followup(prompt) and st.session_state.latest_result is None
|
||
else
|
||
"memory_lookup"
|
||
if wants_memory_lookup(prompt)
|
||
else "research_run"
|
||
if wants_brief_run(prompt, st.session_state.context)
|
||
else "chat"
|
||
)
|
||
wants_run = prompt_intent == "research_run"
|
||
if wants_run:
|
||
try:
|
||
parsed_context = asyncio.run(enrich_context_with_llm(prompt)) or parsed_context
|
||
except Exception:
|
||
pass
|
||
|
||
with st.chat_message("assistant"):
|
||
followup = (
|
||
followup_response(prompt, st.session_state.latest_result)
|
||
if prompt_intent == "followup"
|
||
else None
|
||
)
|
||
if prompt_intent == "followup" and followup:
|
||
response = followup
|
||
st.markdown(response)
|
||
elif prompt_intent == "no_report_followup":
|
||
response = (
|
||
"I don’t have a generated report in this session yet, so there isn’t idea evidence to show. "
|
||
"Tell me about the product and audience, then ask me to find trends or suggest talk/blog ideas."
|
||
)
|
||
st.markdown(response)
|
||
elif prompt_intent == "memory_lookup":
|
||
with st.spinner("Checking Engram Memory..."):
|
||
response = asyncio.run(search_memory_answer(prompt))
|
||
st.markdown(response)
|
||
elif wants_run and missing_fields(st.session_state.context):
|
||
response = conversational_response(
|
||
prompt,
|
||
st.session_state.context,
|
||
st.session_state.latest_result,
|
||
) or assistant_prompt_for_missing()
|
||
st.markdown(response)
|
||
elif wants_run and not missing_fields(st.session_state.context):
|
||
if not os.getenv("NEBIUS_API_KEY"):
|
||
response = "I need a Nebius API key before I can run the autonomous agent team. Add it in the sidebar and click Save API Keys."
|
||
st.warning(response)
|
||
else:
|
||
context = CompanyContext(**st.session_state.context)
|
||
st.session_state.stage_messages = []
|
||
reset_pipeline_steps()
|
||
st.caption(
|
||
"Running Agno agents: GLM chooses HN/DEV searches, then HN, DEV.to, and Engram facts are gathered in parallel. "
|
||
"Live progress appears below."
|
||
)
|
||
started_at = time.time()
|
||
st.session_state.is_running = True
|
||
try:
|
||
with st.status(
|
||
f"Running {APP_NAME}...",
|
||
expanded=True,
|
||
) as status:
|
||
pipeline_view = st.empty()
|
||
progress_log = st.empty()
|
||
|
||
def update_progress(message: str) -> None:
|
||
elapsed = int(time.time() - started_at)
|
||
status.update(
|
||
label=f"{message} ({elapsed}s elapsed)",
|
||
state="running",
|
||
)
|
||
pipeline_view.markdown(render_pipeline_stepper())
|
||
progress_log.markdown(
|
||
render_progress_log(st.session_state.stage_messages)
|
||
)
|
||
|
||
result = asyncio.run(
|
||
run_brief(
|
||
context,
|
||
st.session_state.limit,
|
||
on_progress=update_progress,
|
||
)
|
||
)
|
||
elapsed = int(time.time() - started_at)
|
||
status.update(
|
||
label=f"Research complete in {elapsed}s",
|
||
state="complete",
|
||
)
|
||
pipeline_view.markdown(render_pipeline_stepper())
|
||
progress_log.markdown(
|
||
render_progress_log(st.session_state.stage_messages)
|
||
)
|
||
|
||
st.session_state.latest_result = result
|
||
trends = result.report.trend_digest[:3]
|
||
ideas = result.report.content_ideas[:3]
|
||
summary_lines = [
|
||
f"Done. Found {len(result.report.trend_digest)} trends and "
|
||
f"{len(result.report.content_ideas)} talk/blog ideas."
|
||
]
|
||
if trends:
|
||
summary_lines.append("")
|
||
summary_lines.append("Top trends:")
|
||
for i, trend in enumerate(trends, 1):
|
||
summary_lines.append(
|
||
f"{i}. **{trend.topic}** (intensity {trend.intensity_score})"
|
||
)
|
||
if ideas:
|
||
summary_lines.append("")
|
||
summary_lines.append("Top ideas:")
|
||
for i, idea in enumerate(ideas, 1):
|
||
summary_lines.append(
|
||
f"{i}. **{idea.title}** ({idea.format}, score {idea.score})"
|
||
)
|
||
summary_lines.append("")
|
||
summary_lines.append("See the full report below, or download as Markdown.")
|
||
response = "\n".join(summary_lines)
|
||
st.markdown(response)
|
||
except Exception as exc:
|
||
response = f"Content report generation failed: {exc}"
|
||
st.error(response)
|
||
finally:
|
||
st.session_state.is_running = False
|
||
elif parsed_context:
|
||
context_summary = render_context_summary(st.session_state.context)
|
||
response = f"{context_summary}\n\n{assistant_prompt_for_missing()}"
|
||
st.markdown(response)
|
||
elif chat_response := conversational_response(
|
||
prompt,
|
||
st.session_state.context,
|
||
st.session_state.latest_result,
|
||
):
|
||
response = chat_response
|
||
st.markdown(response)
|
||
else:
|
||
response = assistant_prompt_for_missing()
|
||
st.markdown(response)
|
||
st.session_state.messages.append({"role": "assistant", "content": response})
|
||
if parsed_context and has_required_context(st.session_state.context):
|
||
try:
|
||
asyncio.run(
|
||
store_product_context_memory(CompanyContext(**st.session_state.context))
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
if st.session_state.latest_result:
|
||
result = st.session_state.latest_result
|
||
st.markdown("---")
|
||
tab_brief, tab_evidence, tab_history = st.tabs(["Report", "Evidence", "Memory & Run History"])
|
||
with tab_brief:
|
||
render_structured_report(result)
|
||
st.download_button(
|
||
"Download Markdown",
|
||
data=result.markdown,
|
||
file_name="developer_trend_ideation_report.md",
|
||
mime="text/markdown",
|
||
use_container_width=True,
|
||
)
|
||
with tab_evidence:
|
||
render_grouped_evidence(result)
|
||
with st.expander("Query plan", expanded=True):
|
||
st.json(result.query_plan.to_dict())
|
||
with tab_history:
|
||
st.markdown("#### Engram Memory")
|
||
st.caption(
|
||
"Cross-session product research summaries stored in Weaviate Engram "
|
||
f"(user: `{st.session_state.engram_user_id}`). "
|
||
"Search is user-wide across old sessions in the same group; conversation id is stored only as metadata. "
|
||
"Only compact trend and idea summaries are persisted, not agent run logs."
|
||
)
|
||
st.markdown(f"**Group:** `{get_settings(require_nebius=False).engram_namespace}`")
|
||
st.markdown("**Old-session retrieval:** enabled through stable user/group search.")
|
||
if result.memory_notes:
|
||
for note in result.memory_notes:
|
||
st.markdown(f"- {note}")
|
||
else:
|
||
st.info("No Engram store confirmation for this run.")
|
||
preview = build_research_summary_preview(
|
||
result.context,
|
||
result.report,
|
||
result.content_gaps,
|
||
)
|
||
if preview:
|
||
st.markdown("**Stored summary preview**")
|
||
st.markdown(preview)
|
||
|
||
st.markdown("#### This run — Report checks")
|
||
st.caption("Local formatting and evidence-link checks for this report only; Engram stores only compact memories.")
|
||
if result.judge_score is not None:
|
||
st.markdown(f"**Score:** {result.judge_score:.0f}/10")
|
||
if result.judge_notes:
|
||
for note in result.judge_notes:
|
||
st.markdown(f"- {truncate_judge_note(note)}")
|
||
elif result.judge_score is None:
|
||
st.caption("No separate judge run recorded for this fast path.")
|
||
|
||
st.markdown("#### This run — Agent progress")
|
||
st.caption("Live pipeline log from the current Streamlit session.")
|
||
if st.session_state.stage_messages:
|
||
for stage in st.session_state.stage_messages:
|
||
st.markdown(f"- {stage}")
|
||
else:
|
||
st.caption("No stage log captured for this run.")
|
||
|
||
if result.team_member_responses:
|
||
st.markdown("#### This run — Member responses")
|
||
for note in result.team_member_responses:
|
||
st.markdown(f"- {note}")
|
||
|
||
st.markdown("#### Agno session trace")
|
||
st.caption(
|
||
"This is the current Streamlit session's agent progress log. "
|
||
"Cross-session memory is stored only in Engram."
|
||
)
|
||
st.caption(f"Conversation scope: `{st.session_state.conversation_id}`")
|