Initial Commit

.env

@@ -0,0 +1 @@
+GEMINI_API_KEY="AIzaSyC-46PxhMR-cze_KwETlwBj6fA_ETmbFSk"

data.txt

@@ -0,0 +1,9 @@
+The Iridium 9603 is a very small satellite communication module used for sending and receiving short data messages. It works through the Iridium satellite network, which covers the entire Earth — including oceans, mountains, and polar regions. Because of this, the module can be used in remote areas where there is no mobile network.
+
+One of the main advantages of the Iridium 9603 is its small size. It is one of the smallest satellite transceivers available. This makes it suitable for compact devices, portable trackers, and battery-powered equipment. It is commonly used in GPS trackers, fleet monitoring, emergency alert devices, and environmental sensors. 
+
+The device works on the Iridium Short Burst Data (SBD) service. This allows it to send small packets of data very quickly, with low delay, because the satellites are in low Earth orbit. Messages travel faster than with high-altitude satellites, making communication more responsive. 
+
+The module does not require a SIM card, and it uses simple AT commands, making it easy to integrate with microcontrollers and embedded systems. It also has a single connector for power and data control, which simplifies hardware design. It can also notify the user automatically when new messages are waiting. 
+
+The Iridium 9603 can operate in harsh conditions — from -40°C to +85°C — and works even in humid environments. It meets regulatory standards like FCC and CE, meaning it is approved for use in major regions around the world.

faiss_index/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f882e7230ffd50b4275bc0d529f1bbc6f43282e3302a0b65165e2a5172405ff7
+size 1973

ingest.py

@@ -0,0 +1,62 @@
+import os
+import time
+from dotenv import load_dotenv
+from langchain_community.document_loaders import TextLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+load_dotenv()
+api_key = os.getenv("GEMINI_API_KEY")
+
+# --- 1. Load Document ---
+print("Loading document...")
+loader = TextLoader("data.txt")
+documents = loader.load()
+
+# --- 2. Split Document ---
+print("Splitting text...")
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+texts = text_splitter.split_documents(documents)
+
+if not texts:
+    print("No text found in 'data.txt'. Exiting.")
+    exit()
+
+# --- 3. Create Embeddings & Vector Store ---
+print("Initializing embeddings...")
+embeddings = GoogleGenerativeAIEmbeddings(
+    model="gemini-embedding-001",
+    google_api_key=api_key
+)
+
+# Set a reasonable batch size (Google's API limit is 100)
+batch_size = 90
+db = None
+
+try:
+    # Create the vector store with the first batch
+    first_batch = texts[0:batch_size]
+    print(f"Creating vector store with initial batch (0 to {len(first_batch)})...")
+    db = FAISS.from_documents(first_batch, embeddings)
+
+    # Now, add the rest of the batches
+    for i in range(batch_size, len(texts), batch_size):
+        batch = texts[i:i+batch_size]
+        print(f"Adding batch {i} to {i+len(batch)}...")
+        
+        # Use add_documents to add to the existing index
+        db.add_documents(batch) 
+        
+        # Optional: Add a small delay if you still see rate limit errors
+        # time.sleep(1) 
+
+    # --- 4. Save the final vector store ---
+    db.save_local("faiss_index")
+    print("\nDone. Vector store saved as 'faiss_index'")
+
+except Exception as e:
+    print(f"\n--- AN ERROR OCCURRED ---")
+    print(f"{e}")
+    print("\nThis was likely a network timeout or API issue.")
+    print("Please check your firewall/VPN settings and try running the script again.")

main.py

@@ -0,0 +1,70 @@
+import os
+from dotenv import load_dotenv
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+# --- Imports for LCEL ---
+# We replace the create_..._chain imports with these building blocks
+from operator import itemgetter  # A handy tool to get a value from a dict
+from langchain_core.runnables import RunnablePassthrough, RunnableParallel
+from langchain_core.output_parsers import StrOutputParser
+# --- End of new imports ---
+
+from langchain_community.vectorstores import FAISS
+from langchain_google_genai import ChatGoogleGenerativeAI, GoogleGenerativeAIEmbeddings
+from langchain_core.prompts import PromptTemplate
+
+# --- 1. SETUP (Your code is perfect) ---
+load_dotenv()
+api_key = os.getenv("GEMINI_API_KEY")
+
+app = FastAPI()
+
+# Initialize your models and retriever
+embeddings = GoogleGenerativeAIEmbeddings(
+    model="gemini-embedding-001", google_api_key=api_key
+)
+vector_store = FAISS.load_local("faiss_index", embeddings, allow_dangerous_deserialization=True)
+retriever = vector_store.as_retriever()
+
+llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash", google_api_key=api_key)
+
+# Your prompt template
+template = """
+You are a helpful AI assistant. Answer the user's question based on the
+following context. If you don't know the answer, just say "I don't know."
+
+Context: {context}
+Question: {input}
+"""
+prompt = PromptTemplate.from_template(template)
+
+
+# --- 2. BUILD YOUR CHAIN WITH LCEL ---
+
+# This is the equivalent of 'create_stuff_documents_chain'
+# It "stuffs" the context and input into the prompt, then calls the model.
+document_chain = prompt | llm | StrOutputParser()
+
+# This is the equivalent of 'create_retrieval_chain'
+# It defines the full RAG process.
+retrieval_chain = RunnableParallel(
+    # "context": Run the retriever on the user's "input"
+    context=(itemgetter("input") | retriever), 
+    # "input": Pass the user's "input" straight through
+    input=itemgetter("input")
+) | document_chain # Pipe the resulting {context, input} dict into our document_chain
+
+
+# --- 3. YOUR API (No changes needed) ---
+
+class Query(BaseModel):
+    query: str
+
+@app.post("/ask")
+async def ask_query(query: Query):
+    # Use the .invoke() method on your new LCEL chain
+    # It expects a dictionary matching the 'itemgetter' keys
+    response = retrieval_chain.invoke({"input": query.query})
+    
+    return {"answer": response}