Upload 17 files

article_recommendation.py

@@ -0,0 +1,92 @@
+from dotenv import load_dotenv
+import json
+import streamlit as st
+import utils.settings as settings
+
+from crew.article_suggestion import article_recommendation_crew
+from utils.write_to_json import write_dict_to_json as write_dict_to_json
+load_dotenv()
+settings.init()
+
+
+def icon(emoji: str):
+    """Shows an emoji as a Notion-style page icon."""
+    st.write(
+        f'<span style="font-size: 78px; line-height: 1">{emoji}</span>',
+        unsafe_allow_html=True,
+    )
+
+
+def main():
+    icon("📖 Articles RecommendAIgent")
+    st.subheader("Let AI agents recommend articles based on your interest!")
+
+    with st.sidebar:
+        st.header("👇 Provide Your Interests Below!")
+        with st.form("user_input_form", border=True):
+            interests = st.text_input(
+                "Enter your interests (comma-separated):",
+                "GenAI, Architecture, Agentic Programming",
+            )
+            previous_article_insights = st.text_area(
+                "Enter previous article insights:",
+                "Agentic Design Patterns (https://www.deeplearning.ai/the-batch/how-agents-can-improve-llm-performance/)\n"
+                "Reflection: The LLM examines its own work to come up with ways to improve it. "
+                "Tool Use: The LLM is given tools such as web search, code execution, or any other function to help it gather information, take action, or process data. "
+                "Planning: The LLM comes up with, and executes, a multistep plan to achieve a goal "
+                "Multi-agent collaboration: More than one AI agent work together, splitting up tasks and discussing and debating ideas, to come up with better solutions than a single agent would.\n\n"
+                "GenAI Multi-Agent Systems (https://thenewstack.io/genai-multi-agent-systems-a-secret-weapon-for-tech-teams/)\n"
+                "Multi-agent systems go beyond the task-oriented roles to truly super-charge development and strategy teams. "
+                "Successful multi-agent systems act as a “digital twin” for your development team. "
+                "Different Approaches: 1. Centralized, with one agent in the center that collects and assimilates all the other outputs. "
+                "2. Distributed, where there is no central controller and the agents coordinate directly with one another in an “agent swarm. "
+                "3. Hierarchical, where agents are organized in teams or hierarchical layers.\n\n"
+                "LLM Model Quantisation\n"
+                "Different Methods for Compression: Pruning, Knowledge Distiallation and Quantization."
+                "Quantization process represents the model weights in lower precession which is also known as downcasting."
+                "Quanitzatoin Error is the difference in the weights of the quantized model and the original model."
+                "Advantages of Quanitzation: Reduced memory footprint, increased compute and speed of inferrence."
+                "Disadvantages of Quantization: Less precise.\n\n",
+                height=400,
+            )
+            st.markdown("")
+            submitted = st.form_submit_button("Submit")
+
+    if submitted:
+        with st.status(
+            "🤖 **Agents at work...**", state="running", expanded=True
+        ) as status:
+            with st.container(height=500, border=False):
+                result = article_recommendation_crew.kickoff(
+                    inputs={
+                        "interests": interests,
+                        "previous_article_insights": previous_article_insights,
+                    }
+                )
+            status.update(
+                label="✅ Articles are Ready for Reading!",
+                state="complete",
+                expanded=False,
+            )
+
+        st.subheader("", anchor=False, divider="rainbow")
+
+        articles_list = settings.articles.values()
+
+        if articles_list is None:
+            st.markdown("No articles found.")
+            return
+        else:
+            for article in articles_list:
+                st.markdown(f"# {article['title']}")
+                st.markdown(f"**URL:** [{article['url']}]({article['url']})")
+                st.markdown(f"**Pitch:** {article.get('pitch', '')}")
+                st.markdown(f"**Evaluation Score:** {article.get('evaluation_score', '')}")
+                st.markdown(f"**Evaluation Reason:** {article.get('evaluation_reason', '')}")
+                st.markdown(f"**Reason For Recommendation:** {article.get('reason_for_recommendation', '')}")
+                st.markdown("---")
+
+    if st.sidebar.button("← Back to Main Page"):
+        st.session_state.page = "main"
+if __name__ == "__main__":
+    main()

create_article_pitch.py

@@ -0,0 +1,53 @@
+import json
+import streamlit as st
+
+import utils.settings as settings
+
+from crewai import Task
+from crewai.tasks.task_output import TaskOutput
+from pydantic import BaseModel
+from typing import List
+
+from agents.curiosity_catalyst import curiosity_catalyst
+from tools.scrape_website import scrape_tool
+from tasks.create_learning_profile import learning_profile_task
+from tasks.evaluate_articles import evaluation_task
+
+
+class PitchedArticle(BaseModel):
+    title: str
+    url: str
+    pitch: str
+
+
+class PitchedArticles(BaseModel):
+    articles: List[PitchedArticle]
+
+
+def callback_function(output: TaskOutput):
+    evaluated_articles = json.loads(output.exported_output)
+    st.markdown(evaluated_articles)
+    for article in evaluated_articles['articles']:
+        settings.articles[article['url']]['pitch'] = article['pitch']
+    st.markdown("### Create Article Pitch is executed successfully!")
+
+
+article_pitch_task = Task(
+    description=(
+        "Create a pitch only for the articles that have been evaluated and no other links. "
+        "Craft the pitch so to that it teases the article's most intriguing aspects, "
+        "by posing questions that the article might answer or "
+        "highlighting surprising facts to pique the user's curiosity "
+        " to read the article for incremental learning."
+    ),
+    expected_output=(
+        "List of all the artilces that have been evaluated phase along with their url and pitch statement and no other new urls."
+    ),
+    output_json=PitchedArticles,
+    output_file="pitched_articles.json",
+    tools=[scrape_tool],
+    agent=curiosity_catalyst,
+    async_execution=False,
+    callback=callback_function,
+    context=[learning_profile_task, evaluation_task]
+)

create_learning_profile.py

@@ -0,0 +1,44 @@
+import json
+import streamlit as st
+
+from crewai import Task
+from crewai.tasks.task_output import TaskOutput
+from pydantic import BaseModel
+from typing import List
+
+from agents.learning_profiler import learning_profiler
+
+
+class Topic(BaseModel):
+    name: str
+    insights: List[str]
+
+
+class LearningProfile(BaseModel):
+    topics_of_interests: List[str]
+    learnings: List[Topic]
+    
+def callback_function(output: TaskOutput):
+    st.markdown("### Learning profile of the user:")
+    data=json.loads(output.exported_output)
+    st.markdown(f"**topics_of_interests:** {data['topics_of_interests'][0]}")
+    st.markdown(f"**learnings:**")
+    for topic in data['learnings']:
+        st.markdown(f"*{topic['name']}*:{topic['insights'][0]}")
+
+learning_profile_task = Task(
+    description=(
+        "Create a Learning profile of the user based on "
+        "the following articles and insights he has read in the past: \n"
+        "{previous_article_insights}"
+    ),
+    expected_output=(
+        "A structured learning profile of the user with his interests, topics he has read about "
+        "and insights he has captured on the topics."
+    ),
+    agent=learning_profiler,
+    output_json=LearningProfile,
+    output_file="learning_profile.json",
+    async_execution=False,
+    callback=callback_function
+)

evaluate_articles.py

@@ -0,0 +1,57 @@
+import json
+import streamlit as st
+
+import utils.settings as settings
+
+from crewai import Task
+from crewai.tasks.task_output import TaskOutput
+from pydantic import BaseModel
+from typing import List
+
+from agents.article_evaluator import article_evaluator
+from tasks.create_learning_profile import learning_profile_task
+from tasks.new_article_suggestion import article_suggestion_task
+
+
+class EvaluatedArticle(BaseModel):
+    title: str
+    url: str
+    evaluation_score: int
+    evaluation_reason: str
+
+
+class EvaluatedArticles(BaseModel):
+    articles: List[EvaluatedArticle]
+
+
+def callback_function(output: TaskOutput):
+    evaluated_articles = json.loads(output.exported_output)['articles']
+
+    for article in evaluated_articles:
+        settings.articles[article['url']
+                          ]['evaluation_score'] = article['evaluation_score']
+        settings.articles[article['url']
+                          ]['evaluation_reason'] = article['evaluation_reason']
+    st.markdown("### Evaluate Articles task is executed successfully!")
+
+
+evaluation_task = Task(
+    description=(
+        "Evaluate artilces based on the metric does the articles provide incremenrtal "
+        "learning w.r.t the insights captured by the user. "
+        "Score the articles on the scale of 1 to 10, "
+        "1 being doesn't provide incremental learning and "
+        "10 being provides incremental learning to the user."
+        "Evaluate only articles that have been suggested to the user and no other articles."
+    ),
+    expected_output=(
+        "List of article titles with their URLs, evaluation scores, "
+        "and evaluation reasons w.r.t insights captured by the user."
+    ),
+    output_json=EvaluatedArticles,
+    output_file="evaluated_articles.json",
+    agent=article_evaluator,
+    async_execution=False,
+    callback=callback_function,
+    context=[learning_profile_task, article_suggestion_task]
+)

gemini.py

@@ -0,0 +1,11 @@
+import asyncio
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+try:
+    # Check if there's already a running event loop
+    asyncio.get_event_loop()
+except RuntimeError:
+    # If not, create a new event loop
+    asyncio.set_event_loop(asyncio.new_event_loop())
+
+llm=ChatGoogleGenerativeAI(model="gemini-1.5-flash",verbose=True)

gpt.py

@@ -0,0 +1,3 @@
+from langchain_openai import ChatOpenAI
+
+llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)

helpers.py

@@ -0,0 +1,45 @@
+import streamlit as st
+from crewai.tasks.task_output import TaskOutput
+
+def streamlit_callback(step_output:TaskOutput):
+    st.markdown("---")
+    for step in step_output:
+        if isinstance(step, tuple) and len(step) == 2:
+            action, observation = step
+
+            # Display action information
+            if isinstance(action, dict) and all(key in action for key in ["tool", "tool_input", "log"]):
+                st.markdown(f"**Tool:** {action['tool']}")
+                st.markdown(f"**Tool Input:** {action['tool_input']}")
+                st.markdown(f"**Log:** {action['log']}")
+                if "Action" in action:
+                    st.markdown(f"# 📝 Processing Action...")
+                    st.markdown(f"**Action:** {action['Action']}")
+                st.markdown(f"**Action Input:** ```json\n{action['tool_input']}\n```")
+            elif isinstance(action, str):
+                if action != 'log':
+                    continue
+                st.markdown(f"# Action Result...")
+                st.markdown(f"**Action:** {action}")
+            else:
+                st.markdown(f"**Action:** {str(action)}")
+
+            # Display observation information
+            st.markdown(f"**Thought**")
+            if isinstance(observation, str):
+                observation_lines = observation.split('\n')
+                for line in observation_lines:
+                    if line.startswith('Title: '):
+                        st.markdown(f"**Title:** {line[7:]}")
+                    elif line.startswith('Link: '):
+                        st.markdown(f"**Link:** {line[6:]}")
+                    elif line.startswith('Snippet: '):
+                        st.markdown(f"**Snippet:** {line[9:]}")
+                    elif line.startswith('-'):
+                        st.markdown(line)
+                    else:
+                        st.markdown(line)
+            else:
+                st.markdown(str(observation))
+        else:
+            st.markdown(step)

main.css

@@ -0,0 +1,41 @@
+body {
+    background-color: white;
+    color: #333;
+    font-family: 'Arial', sans-serif;
+    margin: 0;
+    padding: 0;
+}
+.main-title {
+    font-size: 3em;
+    font-weight: bold;
+    margin-top: 20px;
+    text-align: center;
+    color: #007bff;
+}
+.sub-header {
+    font-size: 1.5em;
+    margin: 20px 0;
+    text-align: center;
+    color: #333;
+}
+.card {
+    background-color: #f8f9fa;
+    border-radius: 10px;
+    padding: 20px;  
+    margin: 20px;
+    height:300px;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    text-align: center;
+}
+.card h2 {
+    font-size: 1.5em;
+    color: #007bff;
+}
+.card p {
+    color: #666;
+}
+

new_article_suggestion.py

@@ -0,0 +1,44 @@
+import json
+import streamlit as st
+
+import utils.settings as settings
+
+from crewai import Task
+from crewai.tasks.task_output import TaskOutput
+from pydantic import BaseModel
+from typing import List
+
+from agents.learning_curator import learning_curator
+
+
+class SuggestedArticle(BaseModel):
+    title: str
+    url: str
+    reason_for_recommendation: str
+
+
+class SuggestedArticles(BaseModel):
+    articles: List[SuggestedArticle]
+
+
+def callback_function(output: TaskOutput):
+    suggested_articles = json.loads(output.exported_output)['articles']
+    for article in suggested_articles:
+        settings.articles[article['url']] = article
+    st.markdown("### New Article Suggestion task is executed successfully!")
+
+
+article_suggestion_task = Task(
+    description=(
+        "Find 5 articles from the past 10 days that align with the user's learning interests. "
+        "The articles should provide incremental learning to the user based on their insights."
+    ),
+    expected_output=(
+        "List of article titles along with their links. "
+    ),
+    output_json=SuggestedArticles,
+    output_file="article_suggestions.json",
+    agent=learning_curator,
+    async_execution=False,
+    callback=callback_function,
+)

research_paper.py

@@ -0,0 +1,132 @@
+import streamlit as st
+from crew.research_article_suggester import RecentArticleSuggester
+from streamlit_extras.capture import stdout
+
+
+
+def main():
+   
+    st.markdown(
+        """
+        <style>
+        .main {
+            background-color: #f5f5f5;
+            padding: 20px;
+            border-radius: 10px;
+        }
+        .centered {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            text-align: center;
+        }
+        .title {
+            font-family: 'Helvetica', sans-serif;
+            font-weight: bold;
+            font-size: 36px;
+            color: #1f77b4;
+        }
+        .description {
+            font-family: 'Helvetica', sans-serif;
+            font-size: 18px;
+            color: #333333;
+            margin-top: 10px;
+        }
+        .subheader {
+            font-family: 'Helvetica', sans-serif;
+            font-weight: bold;
+            font-size: 24px;
+            color: #ff7f0e;
+            margin-top: 20px;
+        }
+        .element {
+            background-color: #ffffff;
+            padding: 1rem;
+            border-radius: 8px;
+            box-shadow: 0 0 5px rgba(0, 0, 0, 0.1);
+            margin-bottom: 1rem;
+        }
+        .element h3 {
+            font-size: 24px;
+            color: #1f77b4;
+            margin-bottom: 0.5rem;
+            text-transform: uppercase;
+            padding :10px;
+
+        }
+        .element ul {
+            list-style-type: none;
+            padding: 0;
+            margin: 0;
+        }
+        .element li {
+            font-size: 16px;
+            color: #333333;
+            margin-bottom: 0.5rem;
+        }
+        .element li b {
+            font-size: 22px;
+        }
+
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+
+    st.markdown("<div class='container'>", unsafe_allow_html=True)
+
+    st.markdown(
+        """
+        <div class="centered">
+            <p class="title">Recent Article Suggester</p>
+            <p class="description">Discover recent articles based on your topic of interest using advanced AI.</p>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+    st.sidebar.markdown("<p class='sidebar-header'>Search for the papers you are interested in:</p>", unsafe_allow_html=True)
+    topic = st.sidebar.text_input('Enter a topic:', 'GenAI', key='topic_input', help='Enter a topic of interest')
+
+    if st.sidebar.button('Get Suggestions'):
+
+        with st.status(
+            "🤖 **Agents at work...**", state="running", expanded=True
+        ) as status:
+            with st.container(height=500, border=False):
+                log_container = st.empty()
+                with stdout(log_container.code, terminator=""):
+                    suggester = RecentArticleSuggester()
+                    inputs = {"topic": topic}
+                    results = suggester.kickoff(inputs=inputs)
+            status.update(
+                label="✅ Articles are Ready for Reading!",
+                state="complete",
+                expanded=False,
+            )
+
+        st.subheader("", anchor=False, divider="rainbow")
+
+        if results is None:
+            st.markdown('No articles found.', unsafe_allow_html=True)
+        else:
+
+            st.markdown('<p class="subheader">Results:</p>', unsafe_allow_html=True)
+
+            for element in results:
+                st.markdown(
+                    f"""
+                    <div class="element">
+                        <h3><a href="{element['url']}" target="_blank">{element['title']}</a></h3>
+                        <ul>
+                            {"".join(f"<li style='font-size: 20px;'><b>{key.capitalize()}:</b> {value}</li>" for key, value in element.items() if key != "title")}
+                        </ul>
+                    </div>
+                    """,
+                    unsafe_allow_html=True
+                )
+    if st.sidebar.button("← Back to Main Page"):
+        st.session_state.page = "main"
+if __name__ == "__main__":
+    main()

scrape_website.py

@@ -0,0 +1,14 @@
+from crewai_tools import ScrapeWebsiteTool
+import requests
+from bs4 import BeautifulSoup
+
+scrape_tool = ScrapeWebsiteTool()
+
+def CustomScrapeWebsiteTool(url):
+    response = requests.get(url)
+    parsed = BeautifulSoup(response.content, "html.parser")
+    text = parsed.get_text()
+    text = '\n'.join([i for i in text.split('\n') if i.strip() != ''])
+    text = ' '.join([i for i in text.split(' ') if i.strip() != ''])
+
+    return text

search_web.py

@@ -0,0 +1,3 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+search_tool = TavilySearchResults(max_results=5)

settings.py

@@ -0,0 +1,3 @@
+def init():
+    global articles
+    articles = {}

til_feedback.py

@@ -0,0 +1,56 @@
+import streamlit as st
+from dotenv import load_dotenv
+from crew.til import TilCrew
+from streamlit_extras.capture import stdout
+load_dotenv()
+
+
+
+def main():
+    st.markdown("<div class='container'>", unsafe_allow_html=True)
+
+    st.markdown(
+        """
+        <div class="centered">
+            <p class="title">Today I Learnt Feedback</p>
+            <p class="description">Feedback on Today I Learnt</p>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+    til_content = st.text_area('Enter what you learnt today:',
+                               "* Quantization is the process of reducing the size of LLM models by reducing the underlying weights.\n"
+                               "* The weights are reduced by scaling down the datatypes from a datatype that takes larger space to a data type that takes a smaller space, this is also known as downcasting.\n"
+                               "* Quantization offers benefits such as reduced storage space usage and faster computation.\n"
+                               "* Disadvantages: Answers are less precise\n"
+                               "* I learnt how to use Go Routines to handle concurrency in React.\n",
+                               key='til_content', help='Enter what you learnt today')
+
+    if st.button("Get Feedback"):
+        with st.status(
+            "🤖 **Analysing TIL...**", state="running", expanded=True
+        ) as status:
+            with st.container(height=500, border=False):
+                log_container = st.empty()
+                with stdout(log_container.code, terminator=""):
+                    feedback = TilCrew()
+                    inputs = {"content": til_content}
+                    results = feedback.kickoff(inputs=inputs)["feedback"]
+            status.update(
+                label="✅ Feedback ready!",
+                state="complete",
+                expanded=False,
+            )
+
+        for result in results:
+            st.markdown(f"#### TIL: {result['til']}")
+            st.markdown(f"**Feedback:** {result['feedback']}")
+            if result['feedback'] == "not_ok":
+                st.markdown(f"**Criteria:** {result['feedback_criteria']}")
+                st.markdown(f"**Reason:** {result['reason']}")
+                if result.get('suggestion') is not None:
+                    st.markdown(f"**Suggestion:** {result['suggestion']}")
+
+
+if __name__ == "__main__":
+    main()

til_test.py

@@ -0,0 +1,39 @@
+import pytest
+from growthy_agents.crew.til import TilCrew  # type: ignore
+
+
+examples = [
+    ("The sun rises in the east.", [
+     {"insightful_categorization": 'Low', "factuality_categorization": 'High', "simplicity_categorization": 'High', "grammatical_categorization": 'High'}]),
+    ("* Quantization is the process of reducing the size of LLM models by reducing the underlying weights.\n"
+     "* In quantization the weights are reduced by scaling up the datatypes from a datatype that takes smaller space to a data type that takes a larger space, this is also known as downcasting for example downcasting from int8 to float32.\n"
+     "* Advantages: takes lesser space and increases compute speed.\n"
+     "* Disadvantages: Answers are less precise because of the loss of precision in the LLM model weights.\n", [
+        {"insightful_categorization": 'Meidum', "factuality_categorization": 'High',
+            "simplicity_categorization": 'High', "grammatical_categorization": 'High'},
+        {"insightful_categorization": 'High', "factuality_categorization": 'Low',
+            "simplicity_categorization": 'High', "grammatical_categorization": 'High'},
+        {"insightful_categorization": 'High', "factuality_categorization": 'High',
+            "simplicity_categorization": 'High', "grammatical_categorization": 'High'},
+        {"insightful_categorization": 'High', "factuality_categorization": 'High',
+            "simplicity_categorization": 'High', "grammatical_categorization": 'High'},
+    ]),
+]
+
+
+@pytest.mark.parametrize("input_text, expected_categorizations", examples)
+def test_llm_evaluation(input_text, expected_categorizations):
+    til_crew = TilCrew()
+    til_crew.content = input_text
+    til_crew._gather_feedback()
+    response = til_crew.feedback_results
+
+    for idx, feedback in enumerate(response):
+        assert feedback["insightful_categorization"] == pytest.approx(
+            expected_categorizations[idx]["insightful_categorization"], abs=2.0)
+        assert feedback["factuality_categorization"] == pytest.approx(
+            expected_categorizations[idx]["factuality_categorization"], abs=2.0)
+        assert feedback["simplicity_categorization"] == pytest.approx(
+            expected_categorizations[idx]["simplicity_categorization"], abs=2.0)
+        assert feedback["grammatical_categorization"] == pytest.approx(
+            expected_categorizations[idx]["grammatical_categorization"], abs=2.0)

write_to_json.py

@@ -0,0 +1,9 @@
+import json
+
+def write_dict_to_json(data, filename="data.json", indent=4):
+    try:
+        with open(filename, 'w') as json_file:
+            json.dump(data, json_file, indent=indent)
+        print(f"Successfully wrote dictionary to {filename}")
+    except (IOError, json.JSONDecodeError) as e:
+        print(f"Error writing to JSON file: {e}")