Initial commit

.gitignore

@@ -0,0 +1,50 @@
+# Environment variables
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+chroma_db/  # Vector store directory
+*.log       # Log files
+.pytest_cache/
+.coverage
+htmlcov/
+.mypy_cache/
+.ipynb_checkpoints/
+*.ipynb
+*.pdf       # Uploaded PDFs
+*.txt       # Uploaded text files 

README.md

@@ -0,0 +1,52 @@
+# LangGraph RAG + RAGAS
+
+Built this RAG system to experiment with LangGraph's workflow capabilities and RAGAS metrics. It's a straightforward implementation that lets you upload docs, ask questions, and get quality metrics for each response.
+
+## What it does
+
+- Takes your docs and chunks them semantically (sentence-level similarity with greedy paragraph grouping)
+- Uses ChromaDB to store and retrieve relevant context
+- Spits out responses with RAGAS metrics:
+  - Faithfulness: How well the response sticks to the context
+  - Answer Relevancy: How relevant the answer is to the question
+  - Context Precision: How precise the retrieved context is
+  - Context Recall: How much relevant context was retrieved
+  - Answer Correctness: How accurate the answer is
+- Simple Streamlit UI to interact with it all
+
+## Getting it running
+
+1. Clone the repo
+2. Install the deps:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Toss your OpenAI key in `.env`:
+   ```
+   OPENAI_API_KEY=your_key_here
+   ```
+
+## Using it
+
+1. Run the Streamlit app:
+   ```bash
+   streamlit run app.py
+   ```
+2. Upload your docs in the sidebar
+3. Fire away with questions
+4. Check the metrics to see how well it's doing
+
+## Under the hood
+
+- LangGraph handles the RAG pipeline (retrieve -> generate -> evaluate)
+- ChromaDB stores the vectors with cosine similarity
+- GPT-3.5-turbo generates responses
+- RAGAS evaluates response quality
+- Streamlit for the UI
+
+## Heads up
+
+- Vectors get stored in `chroma_db`
+- Using semantic chunking with sentence-level similarity and paragraph grouping
+- Each response comes with its RAGAS metrics
+- Minimum chunk size is a single sentence, max is 1000 chars 

app.py

@@ -0,0 +1,188 @@
+import streamlit as st
+from rag_graph import rag_graph, vectorstore
+from langchain_core.messages import HumanMessage
+import pandas as pd
+import os
+from dotenv import load_dotenv
+from langchain_experimental.text_splitter import SemanticChunker
+import chardet
+from PyPDF2 import PdfReader
+import io
+import re
+import logging
+from langchain_openai import OpenAIEmbeddings
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+# Set page config
+st.set_page_config(
+    page_title="RAG Application with RAGAS Metrics",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Initialize session state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Initialize embeddings
+embeddings = OpenAIEmbeddings()
+
+# Title
+st.title("🤖 RAG Application with RAGAS Metrics")
+
+def clean_text(text):
+    # Remove extra whitespace
+    text = re.sub(r'\s+', ' ', text)
+    # Remove non-printable characters
+    text = ''.join(char for char in text if char.isprintable())
+    return text.strip()
+
+def split_into_sentences(text):
+    # Split text into sentences
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    return [s.strip() for s in sentences if s.strip()]
+
+def process_text(text):
+    # Clean the text
+    text = clean_text(text)
+    
+    # Split into sentences
+    sentences = split_into_sentences(text)
+    
+    # Initialize text splitter with semantic chunking
+    text_splitter = SemanticChunker(
+        embeddings=embeddings,
+        breakpoint_threshold_type="percentile",
+        breakpoint_threshold_amount=25  # Lower threshold for more semantic grouping
+    )
+    
+    # First chunk sentences semantically
+    sentence_chunks = text_splitter.split_text("\n".join(sentences))
+    
+    # Then combine into paragraphs greedily
+    paragraphs = []
+    current_paragraph = []
+    current_size = 0
+    max_chunk_size = 1000  # Maximum characters per chunk
+    
+    for chunk in sentence_chunks:
+        chunk_size = len(chunk)
+        if current_size + chunk_size <= max_chunk_size:
+            current_paragraph.append(chunk)
+            current_size += chunk_size
+        else:
+            if current_paragraph:
+                paragraphs.append("\n".join(current_paragraph))
+            current_paragraph = [chunk]
+            current_size = chunk_size
+    
+    if current_paragraph:
+        paragraphs.append("\n".join(current_paragraph))
+    
+    return paragraphs
+
+def extract_text_from_pdf(pdf_file):
+    try:
+        pdf_reader = PdfReader(pdf_file)
+        text = ""
+        for page in pdf_reader.pages:
+            page_text = page.extract_text()
+            if page_text:  # Only add if text was extracted
+                text += page_text + "\n"
+        
+        if not text.strip():
+            raise ValueError("No text could be extracted from the PDF")
+            
+        return clean_text(text)
+    except Exception as e:
+        raise ValueError(f"Error extracting text from PDF: {str(e)}")
+
+# Sidebar for document upload
+with st.sidebar:
+    st.header("Document Management")
+    uploaded_file = st.file_uploader("Upload a document", type=["txt", "pdf"])
+    if uploaded_file:
+        try:
+            logger.info(f"Processing uploaded file: {uploaded_file.name}")
+            # Process the document based on file type
+            if uploaded_file.type == "application/pdf":
+                text = extract_text_from_pdf(uploaded_file)
+            else:
+                # For text files, detect encoding
+                raw_data = uploaded_file.getvalue()
+                result = chardet.detect(raw_data)
+                encoding = result['encoding']
+                text = raw_data.decode(encoding)
+            
+            if not text.strip():
+                raise ValueError("No text content found in the document")
+            
+            # Process text into semantic chunks
+            chunks = process_text(text)
+            
+            if not chunks:
+                raise ValueError("No valid text chunks could be created from the document")
+            
+            # Add to vectorstore
+            logger.info(f"Adding {len(chunks)} chunks to vectorstore")
+            vectorstore.add_texts(chunks)
+            
+            st.success("Document processed and added to the knowledge base!")
+            st.info(f"Processed {len(chunks)} chunks of text")
+        except Exception as e:
+            logger.error(f"Error processing document: {str(e)}")
+            st.error(f"Error processing document: {str(e)}")
+
+# Main chat interface
+st.header("Chat with the RAG System")
+
+# Display chat messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# Chat input
+default_question = "What is quantum computing?"
+question = st.text_input("Ask a question", value=default_question)
+if st.button("Submit") or question != default_question:
+    # Add user message to chat history
+    st.session_state.messages.append({"role": "user", "content": question})
+    
+    # Display user message
+    with st.chat_message("user"):
+        st.markdown(question)
+    
+    # Prepare the state for the RAG graph
+    state = {
+        "messages": [HumanMessage(content=question)],
+        "context": "",  # Initialize empty context
+        "response": "",  # Initialize empty response
+        "next": "retrieve"  # Start with retrieval
+    }
+    
+    # Run the RAG graph
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            try:
+                logger.info("Starting RAG process")
+                result = rag_graph.invoke(state)
+                logger.info("RAG process completed")
+                
+                # Display the response and metrics
+                st.markdown(result["response"])
+                st.write("Full Response Data:")
+                st.json(result)
+                
+                # Add assistant response to chat history
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": result["response"]
+                })
+            except Exception as e:
+                logger.error(f"Error in RAG process: {str(e)}")
+                st.error(f"Error generating response: {str(e)}") 

quantum_computing.txt

@@ -0,0 +1,129 @@
+# Introduction to Quantum Computing
+
+Quantum Computing is a revolutionary field of computer science that leverages the principles of quantum mechanics to perform computations. Unlike classical computers that use bits (0s and 1s), quantum computers use quantum bits or qubits, which can exist in multiple states simultaneously. This fundamental difference allows quantum computers to solve certain problems exponentially faster than classical computers.
+
+The field emerged in the 1980s when physicist Richard Feynman proposed that quantum systems could be simulated more efficiently using quantum computers. Since then, significant progress has been made in both theoretical understanding and practical implementation of quantum computing systems.
+
+## Key Concepts in Quantum Computing
+
+### Qubits
+- Qubits are the fundamental units of quantum information
+- They can exist in a superposition of states (both 0 and 1 simultaneously)
+- This property enables quantum computers to process multiple possibilities at once
+- Qubits can be implemented using various physical systems:
+  - Electron spin in quantum dots
+  - Nuclear spin in atoms
+  - Photon polarization
+  - Superconducting circuits
+- The state of a qubit is described by a complex probability amplitude
+- Measurement of a qubit collapses its state to either 0 or 1
+
+### Quantum Gates
+- Quantum gates are the basic building blocks of quantum circuits
+- Common quantum gates include:
+  - Hadamard gate (creates superposition)
+  - CNOT gate (entangles qubits)
+  - Pauli gates (X, Y, Z for basic operations)
+  - Phase shift gates (R, S, T gates)
+  - Toffoli gate (quantum AND operation)
+- Quantum gates must be reversible, unlike classical gates
+- Gates can be combined to create quantum circuits
+- Error rates in quantum gates are a major challenge
+
+### Quantum Algorithms
+Several important quantum algorithms have been developed:
+1. Shor's Algorithm: Efficiently factors large numbers
+   - Can break current RSA encryption
+   - Runs exponentially faster than classical algorithms
+2. Grover's Algorithm: Speeds up unstructured search problems
+   - Provides quadratic speedup
+   - Useful for database searching
+3. Quantum Fourier Transform: Basis for many quantum algorithms
+   - Enables phase estimation
+   - Used in Shor's algorithm
+4. Quantum Machine Learning Algorithms:
+   - Quantum support vector machines
+   - Quantum neural networks
+   - Quantum principal component analysis
+
+## Current State of Quantum Computing
+
+### Hardware Implementations
+Major approaches to building quantum computers include:
+- Superconducting qubits (used by IBM and Google)
+  - Operate at extremely low temperatures
+  - Use Josephson junctions
+  - Currently leading in qubit count
+- Trapped ions (used by IonQ)
+  - High coherence times
+  - Excellent gate fidelities
+  - More complex to scale
+- Topological qubits (pursued by Microsoft)
+  - More resistant to errors
+  - Still in research phase
+  - Based on anyons
+- Photonic quantum computing (used by Xanadu)
+  - Operate at room temperature
+  - Good for quantum communication
+  - Challenging for computation
+
+### Challenges
+Key challenges in quantum computing development:
+1. Quantum Decoherence: Maintaining qubit states
+   - Caused by environmental interactions
+   - Limits computation time
+   - Requires error correction
+2. Error Correction: Dealing with quantum errors
+   - Surface codes most promising
+   - Requires many physical qubits
+   - Complex to implement
+3. Scalability: Building larger quantum systems
+   - Current systems have 50-100 qubits
+   - Need thousands for useful applications
+   - Engineering challenges
+4. Temperature Control: Operating at near absolute zero
+   - Expensive cooling systems
+   - Power consumption issues
+   - Maintenance challenges
+
+## Applications
+
+Quantum computing has potential applications in:
+- Cryptography and cybersecurity
+  - Breaking current encryption
+  - Quantum key distribution
+  - Post-quantum cryptography
+- Drug discovery and material science
+  - Molecular simulation
+  - Protein folding
+  - Material properties prediction
+- Financial modeling and optimization
+  - Portfolio optimization
+  - Risk analysis
+  - Option pricing
+- Artificial intelligence and machine learning
+  - Quantum neural networks
+  - Pattern recognition
+  - Optimization problems
+- Climate modeling and weather prediction
+  - Complex system simulation
+  - Climate pattern analysis
+  - Weather forecasting
+
+## Future Outlook
+
+The field of quantum computing is rapidly evolving:
+- Current quantum computers have 50-100 qubits
+- Goal is to build fault-tolerant quantum computers
+- Hybrid quantum-classical systems are being developed
+- Quantum cloud computing services are becoming available
+- Major milestones expected in next decade:
+  - 1000+ qubit systems
+  - Error-corrected qubits
+  - Practical quantum algorithms
+  - Commercial applications
+- Research areas:
+  - New qubit technologies
+  - Better error correction
+  - Quantum software development
+  - Quantum networking 

rag_graph.py

@@ -0,0 +1,283 @@
+from typing import Dict, List, TypedDict, Annotated
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain_chroma import Chroma
+from langchain_core.output_parsers import StrOutputParser
+from langgraph.graph import Graph, StateGraph, END
+from ragas.metrics import faithfulness, answer_relevancy, context_precision, context_recall, answer_correctness
+from ragas import evaluate
+from datasets import Dataset
+import os
+from dotenv import load_dotenv
+import numpy as np
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+# Define the state
+class AgentState(TypedDict):
+    messages: Annotated[List[HumanMessage | AIMessage], "The messages in the conversation"]
+    context: Annotated[str, "The retrieved context"]
+    response: Annotated[str, "The generated response"]
+    next: str
+
+# Initialize components
+llm = ChatOpenAI(model="gpt-3.5-turbo")
+embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+
+# Initialize Chroma with minimal configuration
+vectorstore = Chroma(
+    persist_directory="./chroma_db",
+    embedding_function=embeddings,
+    collection_name="rag_collection",
+    collection_metadata={"hnsw:space": "cosine"}
+)
+
+# Define the retrieval function
+def retrieve(state: AgentState) -> Dict:
+    try:
+        messages = state["messages"]
+        last_message = messages[-1]
+        logger.info(f"Retrieving context for query: {last_message.content}")
+        
+        # Get relevant documents
+        docs = vectorstore.similarity_search_with_score(
+            last_message.content,
+            k=10  # Increased number of documents
+        )
+        if not docs:
+            logger.warning("No relevant documents found in the knowledge base")
+            raise ValueError("No relevant documents found in the knowledge base")
+
+        # Filter and combine documents - using a lower threshold
+        filtered_docs = []
+        for doc, score in docs:
+            if score > 0.2:  # Lower threshold for more context
+                filtered_docs.append(doc)
+
+        if not filtered_docs:
+            logger.warning("No documents met the similarity threshold, using all retrieved documents")
+            filtered_docs = [doc for doc, _ in docs]  # Use all documents if none meet threshold
+
+        # Sort documents by relevance (using the original scores)
+        sorted_docs = sorted(zip(filtered_docs, [score for _, score in docs if score > 0.2]), 
+                            key=lambda x: x[1], reverse=True)
+        context = "\n\n".join([doc.page_content for doc, _ in sorted_docs])
+        logger.info(f"Using {len(filtered_docs)} documents for context")
+        
+        # Validate context
+        if not context.strip():
+            logger.warning("No valid context could be retrieved")
+            raise ValueError("No valid context could be retrieved")
+            
+        logger.info(f"Retrieved context length: {len(context)} characters")
+        return {"context": context, "next": "generate"}
+    except Exception as e:
+        logger.error(f"Error in retrieval: {str(e)}")
+        return {"context": "", "next": "generate"}
+
+# Define the generation function
+def generate(state: AgentState) -> Dict:
+    try:
+        messages = state["messages"]
+        context = state["context"]
+        
+        if not context.strip():
+            logger.warning("Empty context in generation step")
+            return {
+                "response": "I apologize, but I couldn't find any relevant information in the knowledge base to answer your question. Please try rephrasing your question or upload more relevant documents.",
+                "metrics": {},  # Add empty metrics
+                "next": "evaluate"
+            }
+        
+        logger.info("Generating response with context")
+        # Create prompt with context
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are a helpful assistant specialized in quantum computing. 
+            Use the following context to answer the question. 
+            Guidelines:
+            1. Base your answer strictly on the provided context
+            2. If the context doesn't contain relevant information, say so clearly
+            3. Be specific and technical in your explanations
+            4. Use bullet points or numbered lists when appropriate
+            5. Include relevant examples from the context
+            6. If discussing technical concepts, explain them clearly
+            
+            Context:
+            {context}"""),
+            ("human", "{question}")
+        ])
+        
+        chain = prompt | llm | StrOutputParser()
+        response = chain.invoke({
+            "context": context,
+            "question": messages[-1].content
+        })
+        
+        logger.info(f"Generated response length: {len(response)} characters")
+        
+        # Calculate metrics directly in generate
+        try:
+            dataset = Dataset.from_dict({
+                "question": [messages[-1].content],
+                "contexts": [[context]],
+                "answer": [response],
+                "ground_truth": [context]
+            })
+            
+            metrics_dict = {}
+            result = evaluate(dataset, metrics=[faithfulness, answer_relevancy, context_precision, context_recall, answer_correctness])
+            
+            metrics_dict["faithfulness"] = float(np.mean(result["faithfulness"]))
+            metrics_dict["answer_relevancy"] = float(np.mean(result["answer_relevancy"]))
+            metrics_dict["context_precision"] = float(np.mean(result["context_precision"]))
+            metrics_dict["context_recall"] = float(np.mean(result["context_recall"]))
+            metrics_dict["answer_correctness"] = float(np.mean(result["answer_correctness"]))
+            
+            logger.info(f"Metrics calculated: {metrics_dict}")
+        except Exception as e:
+            logger.error(f"Error calculating metrics: {str(e)}")
+            metrics_dict = {}
+        
+        return {
+            "response": response,
+            "metrics": metrics_dict,  # Include metrics in the response
+            "next": "evaluate"
+        }
+    except Exception as e:
+        logger.error(f"Error in generation: {str(e)}")
+        return {
+            "response": "I apologize, but I encountered an error while generating a response. Please try again.",
+            "metrics": {},  # Add empty metrics
+            "next": "evaluate"
+        }
+
+# Define the RAGAS evaluation function
+def evaluate_rag(state: AgentState) -> Dict:
+    try:
+        messages = state["messages"]
+        context = state["context"]
+        response = state["response"]
+        
+        # Detailed logging of input data
+        logger.info("=== RAGAS Evaluation Debug Info ===")
+        logger.info(f"Question: {messages[-1].content}")
+        logger.info(f"Context length: {len(context)}")
+        logger.info(f"Response length: {len(response)}")
+        logger.info(f"Context preview: {context[:200]}...")
+        logger.info(f"Response preview: {response[:200]}...")
+        
+        # Validate inputs
+        if not context.strip():
+            logger.error("Empty context detected")
+            return {"context": context, "response": response, "metrics": {}, "next": END}
+            
+        if not response.strip():
+            logger.error("Empty response detected")
+            return {"context": context, "response": response, "metrics": {}, "next": END}
+        
+        # Check for minimum content requirements
+        if len(context) < 50:
+            logger.error(f"Context too short: {len(context)} characters")
+            return {"context": context, "response": response, "metrics": {}, "next": END}
+            
+        if len(response) < 20:
+            logger.error(f"Response too short: {len(response)} characters")
+            return {"context": context, "response": response, "metrics": {}, "next": END}
+        
+        logger.info("Creating evaluation dataset...")
+        try:
+            # Create dataset for evaluation
+            dataset = Dataset.from_dict({
+                "question": [messages[-1].content],
+                "contexts": [[context]],
+                "answer": [response],
+                "ground_truth": [context]  # Use context as ground truth for better evaluation
+            })
+            logger.info("Dataset created successfully")
+            
+            # Initialize metrics dictionary
+            metrics_dict = {}
+            
+            # Evaluate each metric separately
+            try:
+                result = evaluate(dataset, metrics=[faithfulness])
+                metrics_dict["faithfulness"] = float(np.mean(result["faithfulness"]))
+                logger.info(f"Faithfulness calculated: {metrics_dict['faithfulness']}")
+            except Exception as e:
+                logger.error(f"Error calculating faithfulness: {str(e)}")
+                metrics_dict["faithfulness"] = 0.0
+            
+            try:
+                result = evaluate(dataset, metrics=[answer_relevancy])
+                metrics_dict["answer_relevancy"] = float(np.mean(result["answer_relevancy"]))
+                logger.info(f"Answer relevancy calculated: {metrics_dict['answer_relevancy']}")
+            except Exception as e:
+                logger.error(f"Error calculating answer_relevancy: {str(e)}")
+                metrics_dict["answer_relevancy"] = 0.0
+            
+            try:
+                result = evaluate(dataset, metrics=[context_precision])
+                metrics_dict["context_precision"] = float(np.mean(result["context_precision"]))
+                logger.info(f"Context precision calculated: {metrics_dict['context_precision']}")
+            except Exception as e:
+                logger.error(f"Error calculating context_precision: {str(e)}")
+                metrics_dict["context_precision"] = 0.0
+            
+            try:
+                result = evaluate(dataset, metrics=[context_recall])
+                metrics_dict["context_recall"] = float(np.mean(result["context_recall"]))
+                logger.info(f"Context recall calculated: {metrics_dict['context_recall']}")
+            except Exception as e:
+                logger.error(f"Error calculating context_recall: {str(e)}")
+                metrics_dict["context_recall"] = 0.0
+            
+            try:
+                result = evaluate(dataset, metrics=[answer_correctness])
+                metrics_dict["answer_correctness"] = float(np.mean(result["answer_correctness"]))
+                logger.info(f"Answer correctness calculated: {metrics_dict['answer_correctness']}")
+            except Exception as e:
+                logger.error(f"Error calculating answer_correctness: {str(e)}")
+                metrics_dict["answer_correctness"] = 0.0
+            
+            logger.info(f"RAGAS metrics calculated: {metrics_dict}")
+            return {"context": context, "response": response, "metrics": metrics_dict, "next": END}
+            
+        except Exception as eval_error:
+            logger.error(f"Error during RAGAS evaluation: {str(eval_error)}")
+            logger.error(f"Error type: {type(eval_error)}")
+            return {"context": context, "response": response, "metrics": {}, "next": END}
+            
+    except Exception as e:
+        logger.error(f"Error in RAGAS evaluation: {str(e)}")
+        logger.error(f"Error type: {type(e)}")
+        return {"context": context, "response": response, "metrics": {}, "next": END}
+
+# Create the workflow
+def create_rag_graph():
+    workflow = StateGraph(AgentState)
+    
+    # Add nodes
+    workflow.add_node("retrieve", retrieve)
+    workflow.add_node("generate", generate)
+    workflow.add_node("evaluate", evaluate_rag)
+    
+    # Add edges
+    workflow.add_edge("retrieve", "generate")
+    workflow.add_edge("generate", "evaluate")
+    workflow.add_edge("evaluate", END)
+    
+    # Set entry point
+    workflow.set_entry_point("retrieve")
+    
+    # Compile
+    app = workflow.compile()
+    return app
+
+# Create the graph
+rag_graph = create_rag_graph() 

requirements.txt

@@ -0,0 +1,8 @@
+langchain>=0.1.0
+langgraph>=0.0.15
+ragas>=0.1.0
+streamlit>=1.32.0
+python-dotenv>=1.0.0
+chromadb>=0.4.22
+openai>=1.12.0
+tiktoken>=0.6.0 

test_document.txt

@@ -0,0 +1,26 @@
+The Road Not Taken By Robert Frost
+
+Two roads diverged in a yellow wood,
+And sorry I could not travel both
+And be one traveler, long I stood
+And looked down one as far as I could
+To where it bent in the undergrowth;
+
+Then took the other, as just as fair,
+And having perhaps the better claim,
+Because it was grassy and wanted wear;
+Though as for that the passing there
+Had worn them really about the same,
+
+And both that morning equally lay
+In leaves no step had trodden black.
+Oh, I kept the first for another day!
+Yet knowing how way leads on to way,
+I doubted if I should ever come back.
+
+I shall be telling this with a sigh
+Somewhere ages and ages hence:
+Two roads diverged in a wood, and I—
+I took the one less traveled by,
+And that has made all the difference.
+