reinitialized commit

.gitignore

@@ -0,0 +1,4 @@
+venv/
+leave/
+.env
+.DS_Store

README.md

@@ -0,0 +1,162 @@
+# Blog Evaluator
+
+![alt text](image.png)
+![alt text](image-1.png)
+
+# Blog Generation Workflow
+
+## Overview
+This project implements an **Evaluator-Optimizer Workflow** using **LangGraph** and **LangChain** to generate and refine short blogs. The workflow follows an iterative process where an LLM generates a blog, evaluates it against predefined criteria, and either accepts it or provides feedback for revision. This ensures that the final output meets quality standards.
+
+## Why This Workflow Works
+The **Evaluator-Optimizer Workflow** is effective because it automates content generation while maintaining **quality control** through an LLM-powered evaluation loop. If the initial blog meets the set criteria (**concise, engaging, structured with subtitles and a conclusion**), it is accepted. Otherwise, the LLM provides feedback, and the blog is regenerated with improvements.
+
+## Features
+- **Automated Blog Generation**: Generates a blog based on a given topic.
+- **Evaluation & Feedback**: Reviews the blog for conciseness, structure, and entertainment value.
+- **Iterative Refinement**: If the blog needs revision, feedback is provided, and a revised version is generated.
+- **LangSmith Studio Integration**: Visualizes and tests workflow execution.
+
+## Workflow Overview
+```mermaid
+graph TD;
+    A[Start] --> B[Generate Blog];
+    B --> C[Evaluate Blog];
+    C -->|Needs Revision| B;
+    C -->|Accepted| D[End];
+```
+- **Generates** an initial blog based on the provided topic.
+- **Evaluates** the blog and determines if it meets quality standards.
+- **Routing Decision**:
+  - If the blog is **good**, the workflow **ends**.
+  - If the blog **needs revision**, feedback is given, and a new version is generated.
+
+## Setup & Usage
+
+### Install dependencies:
+```bash
+pip install langchain_groq langgraph pydantic python-dotenv
+```
+
+### Set environment variables in a `.env` file:
+```env
+GROQ_API_KEY=your_api_key
+LANGCHAIN_API_KEY=your_langchain_api_key
+```
+
+### Run the script in an IDE or Jupyter Notebook:
+```python
+state = optimizer_workflow.invoke({"topic": "MCP from Anthropic"})
+print(state["blog"])
+```
+
+## Testing in LangSmith Studio
+- Deploy the workflow and **provide only the topic** as input.
+- Monitor execution flow and **validate outputs** by logging into your LangSmith account (Adding @traceable to your function helps track it)
+- You can also test via Langraph dev (ensure you have the langgraph.json file for this)
+
+
+# Parallelized Code Review with LLMs
+![alt text](image-2.png)
+
+## Introduction
+This project demonstrates a **parallelized workflow** for **automated code review** using **large language models (LLMs)**. Instead of running feedback checks sequentially, the system executes multiple review processes **in parallel**, making it an **efficient and scalable** solution for code assessment.
+
+### Why Parallelization?
+- **Faster Execution:** Multiple feedback checks run **simultaneously**, reducing the overall processing time.
+- **Improved Scalability:** New review criteria can be added without significant slowdowns.
+- **Better Resource Utilization:** Leverages LLM calls efficiently by distributing tasks.
+
+## Features
+- **Readability Analysis**: Evaluates the clarity and structure of the code.
+- **Security Review**: Identifies potential vulnerabilities.
+- **Best Practices Compliance**: Checks adherence to industry-standard coding best practices.
+- **Feedback Aggregation**: Combines results into a single, structured response.
+
+## How It Works
+1. A **code snippet** is provided as input.
+2. Three independent LLM processes analyze the snippet for:
+   - Readability
+   - Security vulnerabilities
+   - Best practices adherence
+3. The results from these processes are aggregated into a final feedback report.
+
+## Technologies Used
+- **Python**
+- **LangChain** (LLM-based workflow automation)
+- **LangGraph** (Parallel execution of LLM tasks)
+- **Groq API** (LLM inference)
+- **Pydantic & TypedDict** (Data validation)
+- **Dotenv & OS** (Environment variable management)
+
+## Running the Code
+1. Clone this repository:
+  
+2. Install dependencies:
+   ```sh
+   pip install -r requirements.txt
+   ```
+3. Set up your environment variables in .env file
+
+4. Run the script
+ 
+
+## Testing in LangSmith Studio
+- Deploy the workflow and **provide only the topic** as input.
+- Monitor execution flow and **validate outputs** by logging into your LangSmith account (Adding @traceable to your function helps track it)
+- You can also test via Langraph dev (ensure you have the langgraph.json file for this)
+
+
+# Learning Path Generator
+![alt text](image-3.png)
+![alt text](image-4.png)
+
+## Overview
+This project implements an **Orchestrator-Synthesizer** workflow to dynamically generate a personalized **learning roadmap** based on a user's existing skills and learning goals. It uses **LangChain, LangGraph, and Groq AI models** to generate structured study plans and topic summaries.
+
+## Why Orchestrator-Synthesizer?
+The **Orchestrator-Synthesizer** pattern is ideal for structured content generation workflows where tasks need to be dynamically assigned, processed independently, and then combined into a final output. It differs from traditional parallelization in the following ways:
+- **Orchestration** dynamically determines what needs to be processed, ensuring relevant tasks are executed based on user input.
+- **Workers** independently generate content summaries for each topic in the study plan.
+- **Synthesis** intelligently merges topic summaries into a well-structured learning roadmap.
+
+This ensures a **scalable, modular, and adaptable** approach to content generation, avoiding unnecessary processing while keeping results contextual.
+
+## Workflow Breakdown
+The workflow consists of three key components:
+
+### 1️⃣ Orchestrator
+- Creates a **study plan** based on the user's **skills and learning goals**.
+- Uses an LLM with a structured output schema to generate a list of **learning topics**.
+
+### 2️⃣ Workers
+- Each **worker** processes an individual **learning topic**.
+- Generates a **markdown-formatted content summary** for the topic, including key concepts and learning resources.
+
+### 3️⃣ Synthesizer
+- Collects all **topic summaries** and organizes them into a **cohesive learning roadmap**.
+- Ensures smooth flow and structured representation of the learning journey.
+
+## Code Structure
+- `orchestrator(state: State)`: Generates the study plan dynamically.
+- `llm_call(state: WorkerState)`: Summarizes a single topic.
+- `synthesizer(state: State)`: Merges all topic summaries into the final roadmap.
+- `assign_workers(state: State)`: Dynamically assigns tasks based on generated topics.
+
+## Running the Workflow
+To generate a personalized learning path, the workflow takes the following inputs:
+
+```python
+user_skills = "Python programming, basic machine learning concepts"
+user_goals = "Learn advanced AI, master prompt engineering, and build AI applications"
+```
+
+It then executes the **Orchestrator → Workers → Synthesizer** pipeline, producing a structured learning roadmap.
+
+## Future Enhancements
+- **Incorporate user feedback loops** to refine study plans over time.
+- **Add multimodal learning resources** (e.g., videos, interactive exercises).
+- **Expand to different learning domains** beyond AI and machine learning.
+---
+
+

app7.py

@@ -0,0 +1,429 @@
+import streamlit as st
+import os
+from typing import Literal, List, Dict, TypedDict, Annotated
+from langchain_groq import ChatGroq
+from pydantic import BaseModel, Field
+from langsmith import traceable
+from langgraph.graph import StateGraph, START, END
+from langchain_core.messages import SystemMessage, HumanMessage
+from langgraph.constants import Send
+import operator
+from langchain_core.prompts import ChatPromptTemplate
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# --- Helper Functions ---
+
+def markdown_converter(text):
+    return st.markdown(text)
+
+
+# --- Blog Evaluator Workflow ---
+
+class BlogState(TypedDict):
+    topic: str
+    blog: str
+    evaluation: str
+    feedback: str
+    accepted: bool
+
+
+def generate_blog(state: BlogState, llm):
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a helpful assistant that generates short blogs."),
+        ("human", "Generate a short blog about: {topic}")
+    ])
+    chain = prompt | llm
+    result = chain.invoke({"topic": state["topic"]}).content
+    return {"blog": result}
+
+
+def evaluate_blog(state: BlogState, llm):
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a strict blog evaluator."),
+        ("human",
+         "Evaluate this blog:\n{blog}\nIs it concise, engaging, structured with subtitles and a conclusion? Respond with 'yes' or 'no'."),
+        ("human", "If the answer is no. provide specific feedback on the needed improvements")
+    ])
+    chain = prompt | llm
+    result = chain.invoke({"blog": state["blog"]}).content
+
+    lines = result.split('\n')
+    evaluation_text = lines[0].strip().lower()
+    if 'no' in evaluation_text:
+        return {"evaluation": "Needs Revision", "feedback": "\n".join(lines[1:]), "accepted": False}
+    else:
+        return {"evaluation": "Accepted", "feedback": "", "accepted": True}
+
+
+def provide_feedback(state: BlogState):
+    return {"feedback": state["feedback"]}
+
+
+def conditional_check(state):
+    if not state["accepted"]:
+        return "revise"
+    else:
+        return "end"
+
+
+def build_blog_graph(llm):
+    def generate_blog_llm(state):
+        return generate_blog(state, llm)
+
+    def evaluate_blog_llm(state):
+        return evaluate_blog(state, llm)
+
+    graph = StateGraph(BlogState)
+    graph.add_node("generate_blog", generate_blog_llm)
+    graph.add_node("evaluate_blog", evaluate_blog_llm)
+    graph.add_node("provide_feedback", provide_feedback)
+    graph.set_entry_point("generate_blog")
+    graph.add_conditional_edges(
+        "evaluate_blog",
+        conditional_check,
+        {
+            "revise": "generate_blog",
+            "end": END
+        }
+    )
+    graph.add_edge("generate_blog", "evaluate_blog")
+    graph.add_edge("provide_feedback", "generate_blog")
+
+    return graph
+
+
+# --- Parallelized Code Review Workflow ---
+
+class CodeReviewState(TypedDict):
+    code_snippet: str
+    readability_feedback: str
+    security_feedback: str
+    best_practices_feedback: str
+    feedback_aggregator: str
+
+
+@traceable
+def get_readability_feedback(state: CodeReviewState, llm):
+    """First LLM call to check code readability"""
+    st.session_state.progress_text = "Analyzing Readability..."
+    msg = llm.invoke([
+        HumanMessage(content=f"Provide readability feedback for the following code:\n\n {state['code_snippet']}")
+    ])
+    return {"readability_feedback": msg.content}
+
+
+@traceable
+def get_security_feedback(state: CodeReviewState, llm):
+    """Second LLM call to check for security vulnerabilities in code"""
+    st.session_state.progress_text = "Analyzing Security..."
+    msg = llm.invoke([
+        HumanMessage(
+            content=f"Check for potential security vulnerabilities in the following code and provide feedback:\n\n {state['code_snippet']}")
+    ])
+    return {"security_feedback": msg.content}
+
+
+@traceable
+def get_best_practices_feedback(state: CodeReviewState, llm):
+    """Third LLM call to check for adherence to coding best practices"""
+    st.session_state.progress_text = "Analyzing Best Practices..."
+    msg = llm.invoke([
+        HumanMessage(
+            content=f"Evaluate the adherence to coding best practices in the following code and provide feedback:\n\n {state['code_snippet']}")
+    ])
+    return {"best_practices_feedback": msg.content}
+
+
+@traceable
+def aggregate_feedback(state: CodeReviewState):
+    """Combine all the feedback from the three LLM calls into a single output"""
+    st.session_state.progress_text = "Aggregating Feedback..."
+    combined = f"Here's the overall feedback for the code:\n\n"
+    combined += f"READABILITY FEEDBACK:\n{state['readability_feedback']}\n\n"
+    combined += f"SECURITY FEEDBACK:\n{state['security_feedback']}\n\n"
+    combined += f"BEST PRACTICES FEEDBACK:\n{state['best_practices_feedback']}"
+    return {"feedback_aggregator": combined}
+
+
+def build_code_review_graph(llm):
+    def get_readability_feedback_llm(state):
+        return get_readability_feedback(state, llm)
+
+    def get_security_feedback_llm(state):
+        return get_security_feedback(state, llm)
+
+    def get_best_practices_feedback_llm(state):
+        return get_best_practices_feedback(state, llm)
+
+    parallel_builder = StateGraph(CodeReviewState)
+
+    # Add nodes
+    parallel_builder.add_node("get_readability_feedback", get_readability_feedback_llm)
+    parallel_builder.add_node("get_security_feedback", get_security_feedback_llm)
+    parallel_builder.add_node("get_best_practices_feedback", get_best_practices_feedback_llm)
+    parallel_builder.add_node("aggregate_feedback", aggregate_feedback)
+
+    # Add edges
+    parallel_builder.add_edge(START, "get_readability_feedback")
+    parallel_builder.add_edge(START, "get_security_feedback")
+    parallel_builder.add_edge(START, "get_best_practices_feedback")
+    parallel_builder.add_edge("get_readability_feedback", "aggregate_feedback")
+    parallel_builder.add_edge("get_security_feedback", "aggregate_feedback")
+    parallel_builder.add_edge("get_best_practices_feedback", "aggregate_feedback")
+    parallel_builder.add_edge("aggregate_feedback", END)
+
+    return parallel_builder.compile()
+
+
+# --- Learning Path Generator Workflow ---
+
+class Topic(BaseModel):
+    name: str = Field(description="Name of the learning topic.")
+    description: str = Field(description="Brief overview of the topic.")
+
+
+class Topics(BaseModel):
+    topics: List[Topic] = Field(description="List of topics to learn.")
+
+
+class State(TypedDict):
+    user_skills: str
+    user_goals: str
+    topics: List[Topic]
+    completed_topics: Annotated[List[str], operator.add]
+    learning_roadmap: str
+
+
+class WorkerState(TypedDict):
+    topic: Topic
+    completed_topics: List[str]
+
+
+@traceable
+def orchestrator(state: State, planner):
+    study_plan = planner.invoke([
+        SystemMessage(
+            content="Create a detailed study plan based on user skills and goals."
+        ),
+        HumanMessage(
+            content=f"User skills: {state['user_skills']}\nUser goals: {state['user_goals']}"
+        ),
+    ])
+    return {"topics": study_plan.topics}
+
+
+@traceable
+def llm_call(state: WorkerState, llm):
+    topic_summary = llm.invoke([
+        SystemMessage(
+            content="Generate a content summary for the provided topic."
+        ),
+        HumanMessage(
+            content=f"Topic: {state['topic'].name}\nDescription: {state['topic'].description}"
+        ),
+    ])
+
+    return {"completed_topics": [topic_summary.content]}
+
+
+@traceable
+def synthesizer(state: State):
+    topic_summaries = state["completed_topics"]
+    learning_roadmap = "\n\n---\n\n".join(topic_summaries)
+    return {"learning_roadmap": learning_roadmap}
+
+
+def assign_workers(state: State):
+    return [Send("llm_call", {"topic": t}) for t in state["topics"]]
+
+
+def build_learning_path_graph(llm, planner):
+    def orchestrator_planner(state):
+        return orchestrator(state, planner)
+
+    def llm_call_llm(state):
+        return llm_call(state, llm)
+
+    learning_path_builder = StateGraph(State)
+
+    learning_path_builder.add_node("orchestrator", orchestrator_planner)
+    learning_path_builder.add_node("llm_call", llm_call_llm)
+    learning_path_builder.add_node("synthesizer", synthesizer)
+
+    learning_path_builder.set_entry_point("orchestrator")
+    learning_path_builder.add_conditional_edges("orchestrator", assign_workers, {"llm_call": "llm_call"})
+    learning_path_builder.add_edge("llm_call", "synthesizer")
+    learning_path_builder.add_edge("synthesizer", END)
+
+    return learning_path_builder
+
+
+# --- Streamlit App ---
+
+st.set_page_config(page_title="LLM-Powered Workflows", layout="wide")
+
+# Custom CSS for colors
+st.markdown(
+    """
+    <style>
+        [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
+            background-color: #FF7F50; /* Coral */
+        }
+        [data-testid="stAppViewContainer"] {
+          background-color: #FF1493; /* Deep Pink */
+        }
+        
+        /* Adjusting main content text color */
+        .block-container {
+          color: #9400D3; /* Dark Violet */
+        }
+         /* for all text */
+        body {
+          color: #9400D3 !important; /* Dark Violet */
+        }
+
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
+
+
+st.title("Try out LLM-Powered Workflows")
+st.markdown("""
+    <p style='color:#9400D3; font-size: 20px;'>
+        <b>1. Learning Path Generator</b> - Orchestrator-Synthesizer Workflow<br>
+        <b>2. Peer Code Review</b> - Parallelized Workflow<br>
+        <b>3. Blog Generation</b> - Evaluator-Optimizer Workflow
+    </p>
+    <p style='color:#9400D3;'><b>Enter your GROQ API key on the left to get started!</b></p>
+    """, unsafe_allow_html=True)
+
+# Initialize session state
+if "model_choice" not in st.session_state:
+    st.session_state.model_choice = "mixtral-8x7b-32768"
+if "progress_text" not in st.session_state:
+    st.session_state.progress_text = ""
+if "api_key_submitted" not in st.session_state:
+    st.session_state.api_key_submitted = False
+# Sidebar for API key, model selection, and workflow selection
+with st.sidebar:
+    st.header("Configuration")
+    groq_api_key_input = st.text_input("Enter your Groq API Key:", type="password", key="api_key_input")
+    api_key_submitted = st.button("Submit API Key")
+    
+    available_models = ["mixtral-8x7b-32768", "deepseek-r1-distill-qwen-32b", "qwen-2.5-32b", "llama-3.1-8b-instant"]
+    
+    llm = None
+    planner = None
+
+    if api_key_submitted:
+        st.session_state.api_key_submitted = True
+
+    if st.session_state.api_key_submitted:
+        if groq_api_key_input:
+            os.environ["GROQ_API_KEY"] = groq_api_key_input
+        elif os.environ.get("GROQ_API_KEY"):
+            groq_api_key_input = os.environ.get("GROQ_API_KEY")
+
+        if groq_api_key_input or os.environ.get("GROQ_API_KEY"):
+            try:
+                llm = ChatGroq(groq_api_key=groq_api_key_input, model_name=st.session_state.model_choice)
+                planner = llm.with_structured_output(Topics)
+                st.success(f"API key loaded successfully!")
+            
+                st.session_state.model_choice = st.selectbox(
+                "Choose a Model",
+                available_models,
+                key="model_select_box",
+                index=available_models.index(st.session_state.model_choice) if st.session_state.model_choice in available_models else 0
+                )
+
+                llm = ChatGroq(groq_api_key=groq_api_key_input, model_name=st.session_state.model_choice)
+                planner = llm.with_structured_output(Topics)
+
+                st.success(f"model '{st.session_state.model_choice}' loaded successfully!")
+
+            except Exception as e:
+                 st.error(f"Error initializing LLM: {e}")
+                 llm = None
+                 planner = None
+        else:
+            st.warning("Please enter your Groq API key to continue.")
+        
+    if llm is not None:
+        # Emojis for workflow choices
+        workflow_emojis = {
+            "Learning Path Generator": "📚 Learning Path",  # Books
+            "Parallelized Code Review": "👨‍💻 Code Review",  # Man technologist
+            "Blog Evaluator": "📝 Blog Evaluator",  # Writing hand
+        }
+
+        # Correct order for selectbox:
+        workflow_order = ["Learning Path Generator", "Parallelized Code Review", "Blog Evaluator"]
+
+        workflow_choice = st.selectbox(
+            "Choose a Workflow",
+            workflow_order,
+            format_func=lambda x: f"{workflow_emojis[x]}",
+            key="workflow_choice"
+        )
+
+# Main content area
+if llm and planner:
+    # Emojis for workflow choices
+    workflow_emojis = {
+            "Learning Path Generator": "📚",  # Books
+            "Parallelized Code Review": "👨‍💻",  # Man technologist
+            "Blog Evaluator": "📝",  # Writing hand
+        }
+    
+    if st.session_state.get("workflow_choice") == "Learning Path Generator":
+        st.header(f"{workflow_emojis['Learning Path Generator']} Learning Path Generator")
+        user_skills = st.text_area("Enter your current skills:")
+        user_goals = st.text_area("Enter your learning goals:")
+        if st.button("Generate Learning Path"):
+            if user_skills and user_goals:
+                learning_graph = build_learning_path_graph(llm, planner)
+                learning_app = learning_graph.compile()
+                result = learning_app.invoke({"user_skills": user_skills, "user_goals": user_goals})
+                st.subheader("Learning Roadmap:")
+                markdown_converter(result["learning_roadmap"])
+            else:
+                st.error("Please enter both your skills and goals")
+                
+    elif st.session_state.get("workflow_choice") == "Parallelized Code Review":
+        st.header(f"{workflow_emojis['Parallelized Code Review']} Parallelized Code Review")
+        code_snippet = st.text_area("Enter code snippet:", height=300)
+        review_button = st.button("Review Code")
+
+        if review_button:
+            if code_snippet:
+                workflow = build_code_review_graph(llm)
+                progress_bar = st.progress(0)
+                progress_bar.progress(25, text="Starting...")
+                result = workflow.invoke({"code_snippet": code_snippet})
+                progress_bar.progress(100, text="Done!")
+                st.subheader("Code Review Feedback:")
+                st.markdown(result["feedback_aggregator"])
+                progress_bar.empty()
+                st.session_state.progress_text = ""
+            else:
+                st.error("Please enter a code snippet to review.")
+        else:
+            st.write(st.session_state.progress_text)
+            
+    elif st.session_state.get("workflow_choice") == "Blog Evaluator":
+        st.header(f"{workflow_emojis['Blog Evaluator']} Blog Evaluator")
+        blog_topic = st.text_input("Enter blog topic:")
+        if st.button("Generate and Evaluate"):
+            if blog_topic:
+                blog_graph = build_blog_graph(llm)
+                blog_app = blog_graph.compile()
+                result = blog_app.invoke({"topic": blog_topic})
+                st.subheader("Blog:")
+                markdown_converter(result["blog"])
+                #only display blog content. No Evaluation or feedback.
+            else:
+                st.error("Please enter a blog topic")

blog_evaluater_optimizer.py

@@ -0,0 +1,98 @@
+import os
+from dotenv import load_dotenv
+from typing import Literal, List, Dict, TypedDict
+from langchain_groq import ChatGroq
+from pydantic import BaseModel, Field
+from langsmith import traceable
+from langgraph.graph import StateGraph, START, END
+from IPython.display import Image, display
+
+load_dotenv()
+
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")
+
+llm = ChatGroq(model="qwen-2.5-32b")
+
+# Graph state
+class State(TypedDict):
+    blog: str
+    topic: str
+    feedback: str
+    good_or_revise: str
+
+
+class Feedback(BaseModel):
+    grade: Literal["good", "needs revision"] = Field(
+        description="Decide if the blog is entertaining, concise with maxiumum of 400 characters, with subtitles and a conclusion or needs revision.",
+    )
+    feedback: str = Field(
+        description="If the blog is not good, provide feedback on how to improve it.",
+    )
+
+
+evaluator = llm.with_structured_output(Feedback)
+
+
+# Nodes
+@traceable
+def llm_call_generator(state: State):
+    """LLM generates a blog"""
+    if state.get("feedback"):
+        msg = llm.invoke(
+            f"Write a blog about {state['topic']} but take into account the feedback: {state['feedback']}"
+        )
+    else:
+        msg = llm.invoke(f"Write a blog about {state['topic']}")
+    
+    # Debugging print statement
+    print("Generated blog content:", msg.content)  
+    
+    return {"blog": msg.content}  # Ensure this key is returned!
+
+
+@traceable
+def llm_call_evaluator(state: State):
+    """LLM evaluates the blog"""
+    grade = evaluator.invoke(f"Grade the blog {state['blog']}")
+    return {"good_or_revise": grade.grade, "feedback": grade.feedback}
+
+
+@traceable
+def route_blog(state: State):
+    """Route back to blog generator or end based upon feedback from evaluator"""
+    if state["good_or_revise"] == "good":
+        return "Accepted"
+    elif state["good_or_revise"] == "needs revision":
+        return "llm_call_generator"
+
+
+# Build workflow
+optimizer_builder = StateGraph(State)
+
+# Add the nodes
+optimizer_builder.add_node("llm_call_generator", llm_call_generator)
+optimizer_builder.add_node("llm_call_evaluator", llm_call_evaluator)
+
+# Add edges to connect nodes
+optimizer_builder.add_edge(START, "llm_call_generator")
+optimizer_builder.add_edge("llm_call_generator", "llm_call_evaluator")
+optimizer_builder.add_conditional_edges(
+    "llm_call_evaluator",
+    route_blog,
+    {
+        "Accepted": END,
+        "llm_call_generator": "llm_call_generator",
+    },
+)
+
+# Compile the workflow
+optimizer_workflow = optimizer_builder.compile()
+
+# Show the workflow
+display(Image(optimizer_workflow.get_graph().draw_mermaid_png()))
+
+# Invoke
+state = optimizer_workflow.invoke({"topic": "Vibe Coding"})
+print(state["blog"])

code_peer_review_parallel.py

@@ -0,0 +1,103 @@
+import os
+from dotenv import load_dotenv
+from typing import TypedDict
+from langchain_groq import ChatGroq
+from pydantic import BaseModel, Field
+from langsmith import traceable
+from langgraph.graph import StateGraph, START, END
+from IPython.display import Image, display
+
+load_dotenv()
+
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")
+
+llm = ChatGroq(model="qwen-2.5-32b")
+
+# Graph state
+class State(TypedDict):
+    code_snippet: str  # input
+    readability_feedback: str  # intermediate
+    security_feedback: str  # intermediate
+    best_practices_feedback: str  # intermediate
+    feedback_aggregator: str  # output
+
+
+# Nodes
+@traceable
+def get_readability_feedback(state: State):
+    """First LLM call to check code readability"""
+    msg = llm.invoke(
+        f"Provide readability feedback for the following code:\n\n {state['code_snippet']}"
+    )
+    return {"readability_feedback": msg.content}
+
+
+@traceable
+def get_security_feedback(state: State):
+    """Second LLM call to check for security vulnerabilities in code"""
+    msg = llm.invoke(
+        f"Check for potential security vulnerabilities in the following code and provide feedback:\n\n {state['code_snippet']}"
+    )
+    return {"security_feedback": msg.content}
+
+
+@traceable
+def get_best_practices_feedback(state: State):
+    """Third LLM call to check for adherence to coding best practices"""
+    msg = llm.invoke(
+        f"Evaluate the adherence to coding best practices in the following code and provide feedback:\n\n {state['code_snippet']}"
+    )
+    return {"best_practices_feedback": msg.content}
+
+
+@traceable
+def aggregate_feedback(state: State):
+    """Combine all the feedback from the three LLM calls into a single output"""
+    combined = f"Here's the overall feedback for the code:\n\n"
+    combined += f"READABILITY FEEDBACK:\n{state['readability_feedback']}\n\n"
+    combined += f"SECURITY FEEDBACK:\n{state['security_feedback']}\n\n"
+    combined += f"BEST PRACTICES FEEDBACK:\n{state['best_practices_feedback']}"
+    return {"feedback_aggregator": combined}
+
+
+# Build workflow
+parallel_builder = StateGraph(State)
+
+# Add nodes - Corrected node names
+parallel_builder.add_node("get_readability_feedback", get_readability_feedback)
+parallel_builder.add_node("get_security_feedback", get_security_feedback)
+parallel_builder.add_node("get_best_practices_feedback", get_best_practices_feedback)
+parallel_builder.add_node("aggregate_feedback", aggregate_feedback)
+
+# Add edges to connect nodes
+parallel_builder.add_edge(START, "get_readability_feedback")
+parallel_builder.add_edge(START, "get_security_feedback")
+parallel_builder.add_edge(START, "get_best_practices_feedback")
+parallel_builder.add_edge("get_readability_feedback", "aggregate_feedback")
+parallel_builder.add_edge("get_security_feedback", "aggregate_feedback")
+parallel_builder.add_edge("get_best_practices_feedback", "aggregate_feedback")
+parallel_builder.add_edge("aggregate_feedback", END)
+
+parallel_workflow = parallel_builder.compile()
+
+# Show workflow - Try and except to handle the timeout
+try:
+    display(Image(parallel_workflow.get_graph().draw_mermaid_png()))
+except Exception as e:
+    print(f"Error generating Mermaid diagram: {e}")
+
+# Invoke
+# Here is an example of a program, you can change it for any python code.
+full_program = """
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+print(os.getenv("LANGCHAIN_API_KEY"))
+"""
+state = parallel_workflow.invoke({"code_snippet": full_program})
+print(state["feedback_aggregator"])
+

learning_path_orchestrator.py

@@ -0,0 +1,141 @@
+import os
+from dotenv import load_dotenv
+from typing import TypedDict, List, Annotated
+from langchain_groq import ChatGroq
+from pydantic import BaseModel, Field
+from langsmith import traceable
+from langgraph.graph import StateGraph, START, END
+from IPython.display import Image, display, Markdown
+from langchain_core.messages import SystemMessage, HumanMessage
+from langgraph.constants import Send
+import operator
+
+# Load environment variables
+load_dotenv()
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")
+
+# Initialize LLM model
+llm = ChatGroq(model="qwen-2.5-32b")
+
+# ----------------------------
+# 1️⃣ Define Custom Data Structures
+# ----------------------------
+
+class Topic(BaseModel):
+    """Represents a learning topic with a name and description."""
+    name: str = Field(description="Name of the learning topic.")
+    description: str = Field(description="Brief overview of the topic.")
+
+class Topics(BaseModel):
+    """Wrapper for a list of learning topics."""
+    topics: List[Topic] = Field(description="List of topics to learn.")
+
+# Augment the LLM with structured schema
+planner = llm.with_structured_output(Topics)
+
+# Define the state that carries data throughout the workflow
+class State(TypedDict):
+    user_skills: str  
+    user_goals: str  
+    topics: List[Topic]  
+    completed_topics: Annotated[List[str], operator.add]  # Merging completed topics
+    learning_roadmap: str  
+
+# Worker state for topic processing
+class WorkerState(TypedDict):
+    topic: Topic
+    completed_topics: List[str]
+
+# ----------------------------
+# 2️⃣ Define Core Processing Functions
+# ----------------------------
+
+@traceable
+def orchestrator(state: State):
+    """Creates a study plan based on user skills and goals."""
+    
+    # LLM generates a structured study plan
+    study_plan = planner.invoke([
+        SystemMessage(
+            content="Create a detailed study plan based on user skills and goals."
+        ),
+        HumanMessage(
+            content=f"User skills: {state['user_skills']}\nUser goals: {state['user_goals']}"
+        ),
+    ])
+
+    print("Study Plan:", study_plan)
+
+    return {"topics": study_plan.topics}  # Returns generated topics
+
+
+@traceable
+def llm_call(state: WorkerState):
+    """Generates a content summary for a specific topic."""
+    
+    # LLM processes the topic and generates a summary
+    topic_summary = llm.invoke([
+        SystemMessage(
+            content="Generate a content summary for the provided topic."
+        ),
+        HumanMessage(
+            content=f"Topic: {state['topic'].name}\nDescription: {state['topic'].description}"
+        ),
+    ])
+
+    return {"completed_topics": [topic_summary.content]}  # Returns generated summary
+
+
+@traceable
+def synthesizer(state: State):
+    """Compiles topic summaries into a structured learning roadmap."""
+    
+    topic_summaries = state["completed_topics"]
+    learning_roadmap = "\n\n---\n\n".join(topic_summaries)  # Formatting output
+
+    return {"learning_roadmap": learning_roadmap}  # Returns final roadmap
+
+# ----------------------------
+# 3️⃣ Define Conditional Edge Function (Before Using It)
+# ----------------------------
+
+def assign_workers(state: State):
+    """Assigns a worker (llm_call) to each topic in the plan."""
+    
+    return [Send("llm_call", {"topic": t}) for t in state["topics"]]  # Creates worker tasks
+
+# ----------------------------
+# 4️⃣ Build Workflow
+# ----------------------------
+
+learning_path_builder = StateGraph(State)
+
+# Add nodes
+learning_path_builder.add_node("orchestrator", orchestrator)
+learning_path_builder.add_node("llm_call", llm_call)
+learning_path_builder.add_node("synthesizer", synthesizer)
+
+# Define execution order using edges
+learning_path_builder.add_edge(START, "orchestrator")  # Start with orchestrator
+learning_path_builder.add_conditional_edges("orchestrator", assign_workers, ["llm_call"])  # Assign workers
+learning_path_builder.add_edge("llm_call", "synthesizer")  # Process topics
+learning_path_builder.add_edge("synthesizer", END)  # End workflow
+
+# Compile workflow
+learning_path_workflow = learning_path_builder.compile()
+
+# ----------------------------
+# 5️⃣ Run the Workflow
+# ----------------------------
+
+user_skills = "Python programming, basic machine learning concepts"
+user_goals = "Learn advanced AI, master prompt engineering, and build AI applications"
+
+state = learning_path_workflow.invoke(
+    {"user_skills": user_skills, "user_goals": user_goals}
+)
+
+# Display the final learning roadmap
+Markdown(state["learning_roadmap"])

orchestrator_data_flow.md

@@ -0,0 +1,63 @@
+Data Flow Breakdown in learning_path_orchestrator
+We follow a structured data pipeline where each step modifies and passes data to the next stage.
+
+1️⃣ Define Custom Data Structures
+- Topic (BaseModel) → Represents a single topic with name and description.
+- Topics (BaseModel) → A wrapper around multiple Topic objects (essentially a list of topics).
+- State (TypedDict) → Holds global state, including user input, generated topics, and completed topics.
+- WorkerState (TypedDict) → Holds individual topic assignments for processing.
+
+2️⃣ Step-by-Step Data Flow
+
+Step 1: Orchestrator Generates Topics
+Input: user_skills and user_goals
+Process: Calls planner.invoke(), which uses an LLM (Groq API) to generate topics.
+Output: A structured Topics object (a list of Topic objects).
+Storage: The topics list is saved inside State.
+Returns: {"topics": study_plan.topics}
+📌 Key Detail:
+The Orchestrator only generates topics and doesn’t process them. It assigns each topic to workers.
+
+Step 2: Assign Workers to Each Topic
+Function: assign_workers(state: State)
+Process: Iterates over state["topics"] and assigns each topic to a worker (i.e., llm_call).
+Returns: A list of dispatch instructions, sending each topic to the llm_call function.
+Key Mechanism:
+Uses Send("llm_call", {"topic": t}), which maps each topic to WorkerState.
+📌 Key Detail:
+This step distributes work in parallel across multiple workers, each handling a single topic.
+
+Step 3: LLM Call Generates Topic Summaries
+Function: llm_call(state: WorkerState)
+Input: A single topic object (from WorkerState).
+Process:
+Calls the LLM (llm.invoke) with the topic's name and description.
+Generates a summary + resources in markdown format.
+Output:
+{"completed_topics": [topic_summary.content]}
+Storage: The summaries are stored inside completed_topics in State.
+📌 Key Detail:
+Each worker only receives one topic at a time. The WorkerState helps isolate one topic per call instead of processing everything at once.
+
+Step 4: Synthesizer Combines Summaries into a Learning Roadmap
+Function: synthesizer(state: State)
+Input: completed_topics list (all processed topics).
+Process: Joins all summaries together into a structured format.
+Output: {"learning_roadmap": learning_roadmap}
+Final Storage: The roadmap is stored inside State.
+📌 Key Detail:
+This step aggregates all topic summaries into a final, structured learning plan.
+
+3️⃣ Where Does the Data Go?
+Step	Function	Input	Output	Where the Data Goes
+1	orchestrator(state)	User skills & goals	topics list	Stored in State["topics"]
+2	assign_workers(state)	Topics list	Send("llm_call", {"topic": t})	Sends each topic to llm_call
+3	llm_call(state)	A single topic	{"completed_topics": [summary]}	Appends to State["completed_topics"]
+4	synthesizer(state)	completed_topics list	learning_roadmap	Stores final roadmap in State["learning_roadmap"]
+
+📝 Key Takeaways
+- Orchestrator generates the topics based on user_skills and user_goals.
+- Workers process each topic separately (using llm_call).
+- WorkerState ensures only one topic is processed per worker to avoid mixing topics.
+- The synthesizer combines all results into a final structured roadmap.
+- Data flows in a structured manner through State and WorkerState, ensuring modular and parallel execution.

requirements.txt

@@ -0,0 +1,17 @@
+langchain 
+python-dotenv
+langchain-openai
+langchain-core
+langchain-community
+bs4
+faiss-cpu
+pypdf
+arxiv
+pymupdf
+wikipedia
+lxml
+langchain_huggingface
+langchain-groq
+langgraph
+langgraph-cli[inmem]
+streamlit