Status: True

Assertion

Genetically modified foods are harmful to human health.

Results

The provided information supports the safety of genetically modified foods in humans, citing numerous scientific studies that assess their safety and health effects. Regulatory bodies such as the FDA and EFSA have approved GMO crops after comprehensive evaluations. Furthermore, organizations like WHO and AMA have affirmed these findings, indicating a consensus among major health authorities on this matter.

– False: This statement would be false if there were no scientific evidence suggesting that genetically modified foods do not pose additional risks to human health compared to conventional foods or if regulatory bodies had not approved GMO crops based on safety assessments. However, the information provided contradicts this assertion by highlighting studies and approvals from reputable authorities.

– Debatable: The classification would be “Debatable” if there were significant conflicting evidence regarding the safety of genetically modified foods or if major health organizations had not yet issued clear statements on their safety in relation to conventional foods, leading to differing opinions among experts and lack of consensus. However, given the information provided, the statement is more accurately classified as true rather than debatable

Assumptions

<|assistant|> – There exists conclusive scientific evidence suggesting genetically modified (GM) foods are not inherently harmful to human health.
– Rigorous safety assessments have been conducted on GM foods by various countries’ regulatory bodies, leading to their approval for consumption.
– Reputable organizations such as the World Health Organization (WHO) and the American Medical Association (AMA) agree that GM foods are not more risky than conventional foods concerning human health safety.
– Genetically modified foods can contribute positively to global challenges like feeding a growing population, reducing environmental impact through increased crop yields, and decreasing pesticide use in agriculture.
– The scientific consensus supports the view that GM foods currently available on the market do not pose greater risks to human health than conventional foods.
– It is essential to rely on factual evidence rather than fear or misinformation when discussing genetically modified food safety and their impact on health.
– The potential benefits of genetically modified foods outweigh any perceived drawbacks, considering the current body of scientific research.
– Public opinion regarding GM foods can vary

Fact Checker Output

output: 1. True – There have been numerous studies over the years that aim to assess the safety and health effects of genetically modified (GM) foods on humans. While there are differing opinions and ongoing research in certain areas, a significant body of scientific evidence suggests GM foods do not pose additional risks compared to conventional foods when it comes to human health.

2. True – Regulatory bodies like the US Food and Drug Administration (FDA), European Food Safety Authority (EFSA), and others have conducted comprehensive safety assessments on GMO crops, leading to their approval for consumption based on the evidence presented during these evaluations.
Writes in detail why it is true or false.

3. True – Both WHO and AMA have issued statements affirming that genetically modified foods are not more risky than conventional foods concerning human health safety, based on the available scientific evidence at their time of issuance. They emphasize a precautionary approach to new technologies while acknowledging the current consensus.

4. True – Genetically modified (GM) crops can offer various benefits addressing global challenges like hung

Model Used

microsoft/Phi-3-mini-4k-instruct-gguf

Script Name

fact_checker_mongodb.py

Script Code

import os
import sys
import requests
from langchain_openai.llms import OpenAI
from langchain.prompts import PromptTemplate
from dotenv import load_dotenv
from statements import get_random_statement
from mongodb_helper import insert_record  # Import MongoDB helper functions
import html

# Load environment variables from .env file
load_dotenv()

# Define category IDs
CATEGORY_IDS = {
    "True": 2,
    "False": 3,
    "Debatable": 4,
    "Unknown": 6
}

def create_wordpress_post(title, content, category):
    data = {
        "title": title,
        "content": content,
        "status": "publish",
        "categories": [CATEGORY_IDS[category]]
    }

    response = requests.post(
        os.getenv("WORDPRESS_POSTS_URL"),
        json=data,
        auth=(os.getenv("WORDPRESS_USERNAME"), os.getenv("WORDPRESS_PASSWORD"))
    )

    if response.status_code == 201:
        print("Blog post created successfully.")
    else:
        print(f"Failed to create blog post: {response.status_code} - {response.text}")

def fact_check(assertion):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))

    # Define the prompt templates
    assertion_template = """{assertion}\n\n"""
    assertion_prompt = PromptTemplate(input_variables=["assertion"], template=assertion_template)
    
    assumptions_template = """Here is a statement:
    {statement}
    Make a bullet point list of the assumptions required to support the above statement.\n\n"""
    assumptions_prompt = PromptTemplate(input_variables=["statement"], template=assumptions_template)
    
    fact_checker_template = """Here is a bullet point list of assertions:
    {assertions}
    For each assumption, determine whether it is true or false. Explain your reasoning.\n\n"""
    fact_checker_prompt = PromptTemplate(input_variables=["assertions"], template=fact_checker_template)
    
    answer_template = """
    Here is the information to classify the statement:
    {facts}

    Based on the above information, how would you classify the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    answer_prompt = PromptTemplate(input_variables=["facts"], template=answer_template)
    
    # Format prompts and extract the string content
    formatted_assertion = assertion_prompt.format_prompt(assertion=assertion).text
    assertion_output = llm.invoke(formatted_assertion)
    
    formatted_assumptions = assumptions_prompt.format_prompt(statement=assertion_output).text
    assumptions_output = llm.invoke(formatted_assumptions)
    
    formatted_fact_checker = fact_checker_prompt.format_prompt(assertions=assumptions_output).text
    fact_checker_output = llm.invoke(formatted_fact_checker)
    
    formatted_answer = answer_prompt.format_prompt(facts=fact_checker_output).text
    final_output = llm.invoke(formatted_answer)
    
    return {
        "assertion_output": assertion_output,
        "assumptions_output": assumptions_output,
        "fact_checker_output": fact_checker_output,
        "final_output": final_output,
    }

def extract_status_and_reasoning(final_output):
    final_output = final_output.strip()
    if "True:" in final_output:
        status_start = final_output.find("True:")
        status = "True"
    elif "False:" in final_output:
        status_start = final_output.find("False:")
        status = "False"
    elif "Debatable:" in final_output:
        status_start = final_output.find("Debatable:")
        status = "Debatable"
    else:
        return "Unknown", final_output

    reasoning = final_output[status_start + len(status) + 1:].strip()
    return status, reasoning

if __name__ == "__main__":
    if len(sys.argv) > 1:
        assertion = sys.argv[1]
    else:
        assertion = get_random_statement()
    
    print(assertion)
    submission = fact_check(assertion)
    
    # Print the detailed outputs to inspect their structure
    for key, value in submission.items():
        print(f"{key}: {value}")
    
    # Extract the final output for status determination and reasoning
    final_output = submission['final_output']
    status, reasoning = extract_status_and_reasoning(final_output)
    
    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name="fact_checker_mongodb.py",
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    print(final_output)
    
    # Create a blog post on WordPress
    blog_title = f"Fact Check: {assertion}"
    blog_content = f"""
    <h1>Status: {status}</h1>
    <h2>Assertion</h2>
    <p>{assertion}</p>
    <h2>Results</h2>
    <p>{reasoning}</p>
    <h3>Assumptions</h3>
    <p>{submission['assumptions_output']}</p>
    <h3>Fact Checker Output</h3>
    <p>{submission['fact_checker_output']}</p>
    <h4>Model Used</h4>
    <p>{os.getenv("MODEL_NAME")}</p>
    <h4>Script Name</h4>
    <p>fact_checker_mongodb.py</p>
    <h4>Script Code</h4>
    <pre>{html.escape(open(__file__).read())}</pre>
    """
    create_wordpress_post(blog_title, blog_content, status)