Agentic workflows: Getting started with AI Agents

You are an AI research assistant tasked with selecting the most relevant and impactful research topic from a list of options. Your goal is to choose a topic that aligns with my preferences, based on previous articles I’ve written. Below are examples of topics I have selected in the past:

"Voyage-Code-3: Smarter, More Efficient Code Retrieval with Nested Embeddings"
"DeepSeek-V3: Training 671 billion parameters with a $6 million dollar budget"
"DeiT Outperforms Experts in Cancer Diagnosis"
"Meta's new LLM architecture: Large Concept Models"
"OpenAI Introduces o3: Pushing the Boundaries of AI Reasoning"
"Meta presents Coconut: Augmenting LLM Reasoning with Latent Thoughts"
"Meta introduces Llama 3.3"
"Google Cloud Introduces Veo and Imagen 3"
"AlphaQubit: Attention is all you need for Quantum Error Correction?"
"OmniVision-968M: A Ultra-lightweight Multimodal Model built on Qwen 2.5"
"Tokenformer: A GPT that uses tokens as parameters"
"Researchers Speed up Diffusion Modeling 17.5x"
"PhysGen: Training-Free Physics Grounding of Image-to-Video Generation"
"Deepmind trains self-correcting LLM's with RL"


These topics typically share the following characteristics:
- Cutting-edge advancements in AI, such as novel architectures, groundbreaking models, or innovative methodologies.
- Large-scale experiments, resource efficiency, or methods that push performance or cost-effectiveness to new limits.
- Real-world applications with transformative potential, such as breakthroughs in healthcare, physics, quantum computing, or multimodal learning.
- A focus on AI reasoning, self-correction, and models that improve through iterative feedback.
- Technical depth that appeals to readers interested in state-of-the-art developments.

Your task:
1. Review the provided list of research results.
2. Analyze each option based on the characteristics above.
3. Select the topic that best aligns with my preferred style and focus areas.
4. Provide a brief explanation of why this topic is the best match, referencing similarities to my previous selections.

Be precise, and ensure the chosen topic reflects both technical innovation and practical significance in AI research.


Note, here are some previous articles that you have selected that I really am not that interested in -- use these to guide your decision making: 

########### beginning of negative preference list 
--- - Papers here you are less interest in ... 

You are an AI assistant. Based on the following text from a research paper, generate a list of major questions that:
1. A reader might want to ask about the paper.
2. Address potential areas of confusion or key points that need clarification.

Please provide a list of meaningful and insightful questions. -- respond with just the questions! 

You are an AI research assistant. Your task is to summarize a research paper based on its content and a list of key questions. The summary should be 300-500 words long, and it must not only summarize the paper’s main ideas, contributions, and results but also attempt to address the provided questions.

Instructions:
1. Write a clear, concise, and comprehensive summary of the paper in 300-500 words.
2. Ensure the summary highlights:
   - The core problem or challenge the paper addresses.
   - The methods, models, or experiments proposed or used in the paper.
   - The key results and insights obtained from the research.
   - The implications or potential applications of the research.
3. Where possible, answer the questions provided based on the content of the paper. If the questions cannot be fully answered, summarize what is known from the provided content.

Be precise and focus on the most important points, ensuring the summary is easy to understand for a technical audience.

I will also give you a previous article that I want you to use as context/as a guide to write the new article.

You are an AI article editor. Your task is to rewrite the provided article to:
1. Ensure all sections have proper headers (unstyled, ending with a colon).
2. Meet the desired word count range (300-500 words).
3. Improve the overall structure and flow of the content.
4. Does not include bullets or lists. 

Return only the new article with the added changes. If no changes are required, just return the full article.

import arxiv
import asyncio
import os
from PyPDF2 import PdfReader
from litellm import acompletion
import weave
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import json
import wandb 
# Initialize Weave
weave.init("news_agent")

# Email configuration
email = "your_email@gmail.com"
pswd = "your app password"
LAST_EMAIL_FILE = "last_email.json"

# Helper function: Run model inference
async def run_inference(query):
    api_key = os.getenv("OPENAI_API_KEY")
    model_name = "gpt-4o-mini"
    response = await acompletion(
        model=model_name,
        api_key=api_key,
        messages=[{"role": "user", "content": query}],
        temperature=0.7,
        max_tokens=1024,
    )
    return response["choices"][0]["message"]["content"]

# Helper function: Read a prompt from a file
def read_prompt(file_path):
    with open(file_path, "r") as file:
        return file.read()

# Helper function: Read a reference article
def read_reference_article(article_file):
    if os.path.exists(article_file):
        with open(article_file, "r") as file:
            return file.read().strip()
    return ""

# Helper function: Format Arxiv results
def format_arxiv_results(results):
    return "[" + ",\n".join(
        [
            f'{{"index": {i+1}, "title": "{result["title"]}", "summary": "{result["summary"]}", "url": "{result["url"]}"}}'
            for i, result in enumerate(results)
        ]
    ) + "]"

# Helper function: Convert Arxiv URL to PDF URL
def convert_to_pdf_url(abs_url):
    return abs_url.replace("/abs/", "/pdf/")

# Helper function: Read the first 10 pages of a PDF
def read_pdf_first_10_pages(pdf_path):
    try:
        with open(pdf_path, "rb") as file:
            reader = PdfReader(file)
            return "\n".join(page.extract_text() for page in reader.pages[:10])
    except Exception:
        return ""

# Arxiv search function
@weave.op
def get_arxiv_possibilities(query, max_results=20):
    search = arxiv.Search(
        query=query,
        max_results=max_results,
        sort_by=arxiv.SortCriterion.SubmittedDate,
    )
    return [
        {"title": result.title, "summary": result.summary.replace("\n", " "), "url": result.entry_id}
        for result in search.results()
    ]

# Select the best Arxiv paper with call ID
@weave.op
async def select_best_arxiv_paper(possibilities, prompt_file):
    if not possibilities:
        return None, None, None

    # Get the Weave call ID
    call_id = weave.get_current_call().id
    formatted_results = format_arxiv_results(possibilities)
    selection_prompt = read_prompt(prompt_file)
    query = f"{selection_prompt}\n\nSearch Results:\n{formatted_results}\n\nRespond with ONLY the URL of the paper you recommend, nothing else."
    selected_response = await run_inference(query)
    selected_url = selected_response.strip()

    # Match the selected URL to possibilities for additional details
    selected_paper = next((item for item in possibilities if item["url"] in selected_url), None)
    return (
        convert_to_pdf_url(selected_url) if selected_url.startswith("http") and "/abs/" in selected_url else None,
        selected_paper["title"] if selected_paper else None,
        call_id,  # Return the Weave call ID
    )

# Generate questions from the paper content
@weave.op
async def generate_questions_from_paper(paper_text, prompt_file):
    question_prompt = read_prompt(prompt_file)
    prompt = f"{question_prompt}\n\nText:\n{paper_text}\n\nPlease provide a list of questions."
    return await run_inference(prompt)

# Generate a summary of the paper
@weave.op
async def generate_summary_from_paper(paper_text, questions, summary_prompt_file, reference_text):
    summary_prompt = read_prompt(summary_prompt_file)
    prompt = (
        f"{summary_prompt}\n\nPREVIOUS Reference Article:\n{reference_text}\n\n"
        f"List of Questions to address in the article:\n{questions}\n\nPaper Content:\n{paper_text}"
    )
    return await run_inference(prompt)

# Edit the generated summary
@weave.op
async def edit_summary(summary, editor_prompt_file):
    editor_prompt = read_prompt(editor_prompt_file)
    prompt = f"{editor_prompt}\n\nArticle Content:\n{summary}"
    return await run_inference(prompt)

# Save email details to a file
async def save_last_email(subject, body, call_id=None, call_url=None):
    """Save the subject, body, Weave call ID, and call URL of the last email sent."""
    with open(LAST_EMAIL_FILE, "w") as f:
        json.dump({"subject": subject, "body": body, "call_id": call_id, "call_url": call_url}, f)
    print(f"Saved last email with call ID: {call_id} and URL: {call_url}")


def get_wandb_username():
    try:
        # Initialize the W&B API
        api = wandb.Api()
        # Fetch the username of the authenticated user
        return api.default_entity
    except Exception as e:
        print(f"Error fetching W&B username: {e}")
        return "unknown_user"

# Send an email
async def send_email(subject, body, recipient_email, sender_email, sender_password, main_call_id=None, selection_call_id=None):
    try:
        # Dynamically fetch W&B username
        username = get_wandb_username()
        call_url = f"https://wandb.ai/{username}/news_agent/r/call/{main_call_id}" if main_call_id else None

        msg = MIMEMultipart()
        msg["From"] = sender_email
        msg["To"] = recipient_email
        msg["Subject"] = subject
        msg.attach(MIMEText(f"{body}\n\nView the process log: {call_url}", "plain"))

        with smtplib.SMTP("smtp.gmail.com", 587) as server:
            server.starttls()
            server.login(sender_email, sender_password)
            server.sendmail(sender_email, recipient_email, msg.as_string())

        print(f"Email sent to {recipient_email}")
        await save_last_email(subject, body, selection_call_id, call_url)
    except Exception as e:
        print(f"Failed to send email: {e}")

# Main function
@weave.op
async def main():
    main_call_id = weave.get_current_call().id

    topic = "machine learning"
    select_prompt_file = "select_research_prompt.txt"
    question_prompt_file = "generate_questions_prompt.txt"
    summary_prompt_file = "summary_prompt.txt"
    editor_prompt_file = "editor_prompt.txt"
    reference_files = ["article1.txt", "article2.txt", "article3.txt"]

    # Step 1: Get Arxiv possibilities
    print("Searching Arxiv...")
    possibilities = get_arxiv_possibilities(topic, max_results=20)

    # Step 2: Select the best paper
    pdf_url, selected_title, selection_call_id = await select_best_arxiv_paper(possibilities, select_prompt_file)
    if not pdf_url:
        print("No paper selected.")
        return

    print(f"Selected Paper: {selected_title}")
    pdf_path = f"{pdf_url.split('/')[-1]}.pdf"
    os.system(f"curl -L {pdf_url} -o {pdf_path}")

    # Step 3: Extract content and generate questions
    paper_text = read_pdf_first_10_pages(pdf_path)
    if not paper_text.strip():
        print("Could not extract any text from the PDF.")
        return

    print("Generating questions based on the paper content...")
    questions = await generate_questions_from_paper(paper_text, question_prompt_file)

    # Step 4: Generate summaries
    all_summaries = ""
    for idx, ref_file in enumerate(reference_files):
        reference_text = read_reference_article(ref_file)
        if not reference_text:
            print(f"Reference article {ref_file} is missing or empty. Skipping...")
            continue

        print(f"\n=== Generating Summary {idx + 1} based on {ref_file} ===")
        summary_output = await generate_summary_from_paper(paper_text, questions, summary_prompt_file, reference_text)

        print(f"Editing Summary {idx + 1}...")
        edited_summary = await edit_summary(summary_output, editor_prompt_file)

        all_summaries += f"=== Edited Summary {idx + 1} based on {ref_file} ===\n{edited_summary}\n\n"

    # Step 5: Email the summaries
    print("Sending email with summaries...")
    await send_email(
        subject=f"{selected_title}",
        body=all_summaries,
        recipient_email=email,
        sender_email=email,
        sender_password=pswd,
        main_call_id=main_call_id,
        selection_call_id=selection_call_id
    )

# Run the main function
asyncio.run(main())


import json
import imaplib
import email as em
import weave

# Initialize Weave
wv_client = weave.init("news_agent")

# Configuration
EMAIL_ACCOUNT = "your_email@gmail.com"
EMAIL_PASSWORD = "your app password"
LAST_EMAIL_FILE = "last_email.json"
PROMPT_FILE = "select_research_prompt.txt"

def load_last_email():
    """Load the last email details."""
    try:
        with open(LAST_EMAIL_FILE, "r") as f:
            return json.load(f)
    except FileNotFoundError:
        return {"title": None, "call_id": None}

def update_prompt(paper_title, feedback):
    """Update the prompt file based on feedback."""
    if not paper_title:
        print("No paper title available to update the prompt.")
        return

    with open(PROMPT_FILE, "r") as f:
        lines = f.readlines()

    # Check if the title already exists in the file
    if any(paper_title in line for line in lines):
        print(f"The paper title '{paper_title}' is already in the prompt file. Skipping update.")
        return

    if feedback == "good":
        lines.insert(2, f'"{paper_title}"\n')  # Add to the top of the "good" section
    elif feedback == "bad":
        lines.append(f'"{paper_title}"\n')  # Add to the "bad" section

    with open(PROMPT_FILE, "w") as f:
        f.writelines(lines)
    
    print(f"Updated prompt with {feedback} feedback for: {paper_title}")

def log_feedback_in_weave(call_id, feedback):
    """Log feedback in Weave."""
    try:
        if 'good' in feedback.lower():
            wv_client.get_call(call_id).feedback.add_reaction("👍")
        elif 'bad' in feedback.lower():
            wv_client.get_call(call_id).feedback.add_reaction("👎")
        print(f"Weave feedback logged: {feedback} for call ID {call_id}")
    except Exception as e:
        print(f"Failed to log feedback in Weave: {e}")

def get_email_body(msg):
    """Extract the plain text body of an email."""
    if msg.is_multipart():
        for part in msg.walk():
            if part.get_content_type() == "text/plain":
                return part.get_payload(decode=True).decode()
    else:
        return msg.get_payload(decode=True).decode()

def check_latest_email():
    """Check the user's latest email for 'good' or 'bad' feedback."""
    # Connect to Gmail
    mail = imaplib.IMAP4_SSL("imap.gmail.com")
    mail.login(EMAIL_ACCOUNT, EMAIL_PASSWORD)
    mail.select("inbox")

    # Search for emails sent by the user to themselves
    status, messages = mail.search(None, f'(FROM "{EMAIL_ACCOUNT}" TO "{EMAIL_ACCOUNT}")')
    email_ids = messages[0].split()

    if not email_ids:
        print("No emails found.")
        return None

    # Fetch the latest email
    latest_email_id = email_ids[-1]
    status, msg_data = mail.fetch(latest_email_id, "(RFC822)")
    raw_email = msg_data[0][1]
    msg = em.message_from_bytes(raw_email)

    # Get the body of the email
    body = get_email_body(msg).strip()
    print(f"Latest email body: {body}")

    # Ignore emails longer than 10 characters
    if len(body) > 10:
        print("Email body is longer than 10 characters. Ignoring.")
        return None

    # Check for feedback
    if "good" in body.lower():
        return "good"
    elif "bad" in body.lower():
        return "bad"
    else:
        print("No actionable feedback found in the email.")
        return None

def main():
    # Load the last sent email
    last_email = load_last_email()
    paper_title = last_email.get("subject")
    call_id = last_email.get("call_id")

    if not paper_title:
        print("No last email title found. Exiting.")
        return

    if not call_id:
        print("No Weave call ID found for the last email. Exiting.")
        return

    # Check for feedback in the latest email
    feedback = check_latest_email()

    if feedback:
        # Update the prompt based on feedback
        update_prompt(paper_title, feedback)

        # Log feedback in Weave
        log_feedback_in_weave(call_id, feedback)

if __name__ == "__main__":
    main()