GPT-OSS Review (2025): OpenAI's Free Model for Your PC

import cv2
import ollama
from ultralytics import YOLO
import json
from datetime import datetime

class VisualQASystem:
    def __init__(self, yolo_model_path="yolov8n.pt", gpt_model="gpt-oss:20b"):
        self.yolo_model = YOLO(yolo_model_path)
        self.gpt_model = gpt_model
        self.class_names = self.yolo_model.names
        
    def detect_objects(self, image):
        results = self.yolo_model(image)
        detections = []
        
        for result in results:
            boxes = result.boxes
            if boxes is not None:
                for box in boxes:
                    class_id = int(box.cls[0])
                    confidence = float(box.conf[0])
                    coords = box.xyxy[0].tolist()
                    
                    detection = {
                        'class': self.class_names[class_id],
                        'confidence': round(confidence, 3),
                        'bbox': coords,
                        'center': [(coords[0] + coords[2])/2, 
                                   (coords[1] + coords[3])/2]
                    }
                    detections.append(detection)
        return detections
    
    def process_frame(self, image, query_type="describe", context=""):
        detections = self.detect_objects(image)
        detection_text = self.format_detection_data(detections, context)
        description = self.generate_description(detection_text, query_type)
        
        return {
            'detections': detections,
            'detection_text': detection_text,
            'description': description,
            'timestamp': datetime.now()
        }

def main():
    vqa_system = VisualQASystem()
    image_path = "ADE_val_00000022.jpg"
    image = cv2.imread(image_path)
    
    result = vqa_system.process_frame(image, query_type="describe", 
                                     context="Street View")
    
    print("=== DETECTION RESULTS ===")
    print(result['detection_text'])
    print("\n=== DESCRIPTION ===")
    print(result['description'])

if __name__ == "__main__":
    main()

(vlm) siya@raman-t:~/testing$ python gpt-oss-visual-qa.py 
0: 608x640 1 car, 70.4ms
Speed: 7.1ms preprocess, 70.4ms inference, 141.4ms postprocess per image

=== DETECTION RESULTS ===
Image Analysis - 03:37:48
Context: Street View
Objects Detected (1 total):
1. car (confidence: 75.4%)
   Location: center at (240, 357)

=== NATURAL LANGUAGE DESCRIPTION ===
At around 3:37 a.m., the camera is looking down a quiet street. 
In the middle of the frame sits a single car—probably parked or 
idling—taking up most of the visible space. No other vehicles, 
pedestrians, or notable objects are detected, so the car is the 
only thing that stands out in this snapshot of the road.

import os
import json
import ollama
import chromadb
from chromadb.config import Settings
from sentence_transformers import SentenceTransformer
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader, TextLoader, DirectoryLoader, Docx2txtLoader
import uuid
from datetime import datetime
from typing import List, Dict, Any

class RAGExpertSystem:
    def __init__(self, 
                 knowledge_base_path="./knowledge_base",
                 vector_db_path="./vector_db",
                 gpt_model="gpt-oss:20b",
                 embedding_model="all-MiniLM-L6-v2"):
        
        # Initialize components
        self.knowledge_base_path = knowledge_base_path
        self.vector_db_path = vector_db_path
        self.gpt_model = gpt_model
        
        # Initialize embedding model
        print("Loading embedding model...")
        self.embedding_model = SentenceTransformer(embedding_model)
        
        # Initialize ChromaDB client
        print("Initializing vector database...")
        self.chroma_client = chromadb.PersistentClient(path=vector_db_path)
        self.collection_name = "expert_knowledge"
        
        try:
            self.collection = self.chroma_client.get_collection(self.collection_name)
            print(f"Loaded existing collection with {self.collection.count()} documents")
        except:
            self.collection = self.chroma_client.create_collection(
                name=self.collection_name,
                metadata={"description": "Expert knowledge base for RAG system"}
            )
            print("Created new collection")
        
        # Initialize text splitter
        self.text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            length_function=len,
        )
        
        print("RAG Expert System initialized successfully!")
    
    def load_documents(self, file_paths: List[str] = None):
        """Load documents from specified paths or directory"""
        documents = []
        
        if file_paths:
            for file_path in file_paths:
                print(f"Loading: {file_path}")
                if file_path.endswith('.pdf'):
                    loader = PyPDFLoader(file_path)
                elif file_path.endswith('.docx'):
                    loader = Docx2txtLoader(file_path)
                elif file_path.endswith('.txt'):
                    loader = TextLoader(file_path)
                else:
                    print(f"Unsupported file type: {file_path}")
                    continue
                
                docs = loader.load()
                documents.extend(docs)
        else:
            if os.path.exists(self.knowledge_base_path):
                print(f"Loading documents from {self.knowledge_base_path}")
                
                pdf_loader = DirectoryLoader(
                    self.knowledge_base_path,
                    glob="**/*.pdf",
                    loader_cls=PyPDFLoader
                )
                
                txt_loader = DirectoryLoader(
                    self.knowledge_base_path,
                    glob="**/*.txt",
                    loader_cls=TextLoader
                )
                
                documents.extend(pdf_loader.load())
                documents.extend(txt_loader.load())
            else:
                print(f"Knowledge base directory {self.knowledge_base_path} not found")
        
        print(f"Loaded {len(documents)} documents")
        return documents
    
    def chat(self, query: str, n_results: int = 5) -> Dict[str, Any]:
        """Complete RAG pipeline: retrieve + generate"""
        print(f"Processing query: {query}")
        
        context_chunks = self.retrieve_relevant_context(query, n_results)
        response = self.generate_expert_response(query, context_chunks)
        
        return {
            'query': query,
            'response': response,
            'context_used': context_chunks,
            'timestamp': datetime.now().isoformat(),
            'sources': list(set([chunk['metadata']['source'] for chunk in context_chunks]))
        }

def main():
    rag_system = RAGExpertSystem()
    
    print("\n=== Loading Knowledge Base ===")
    documents = rag_system.load_documents()
    
    if documents:
        chunks_stored = rag_system.process_and_store_documents(documents)
        print(f"Knowledge base ready with {chunks_stored} chunks!")
    else:
        print("No documents found.")
    
    # Interactive chat loop
    print("\n=== RAG Expert Chat ===")
    print("Ask questions about your knowledge base. Type 'quit' to exit.")
    
    while True:
        query = input("\n🤖 Your Question: ").strip()
        
        if query.lower() in ['quit', 'exit', 'q']:
            break
        
        if not query:
            continue
        
        result = rag_system.chat(query, n_results=3)
        
        print(f"\n📚 Expert Response:")
        print(result['response'])
        
        print(f"\n📄 Sources Used:")
        for source in result['sources']:
            print(f"  - {source}")

if __name__ == "__main__":
    main()

(vlm) siya@raman-t:~/testing$ python gpt-oss-rag.py
/home/siya/testing/gpt-oss-rag.py:8: LangChainDeprecationWarning: Importing PyPDFLoader 
from langchain.document_loaders is deprecated. Please replace deprecated imports:
>> from langchain.document_loaders import PyPDFLoader
with new imports of:
>> from langchain_community.document_loaders import PyPDFLoader

Loading embedding model...
Initializing vector database...
Loaded existing collection with 0 documents
RAG Expert System initialized successfully!

=== Loading Knowledge Base ===
Loading documents from ./knowledge_base
Loaded 898 documents
Processing documents...
Storing 2079 chunks in vector database...
Successfully stored 2079 chunks
Knowledge base ready with 2079 chunks!

=== Knowledge Base Stats ===
Total chunks: 2079
Unique sources: 2
Sample sources: knowledge_base/PythonNotesForProfessionals.pdf, 
knowledge_base/google-ai-agents-whitepaper.pdf

=== RAG Expert Chat ===
Ask questions about your knowledge base. Type 'quit' to exit.

🤖 Your Question: what are AI Agents?
Processing query: what are AI Agents?

📚 Expert Response:
Based on the knowledge base, AI Agents are Generative AI systems that can 
perform tasks and make decisions autonomously. They combine language models 
with tools and orchestration layers to interact with external systems and 
execute complex workflows.

📄 Sources Used:
  - knowledge_base/google-ai-agents-whitepaper.pdf

🔍 Context Chunks (for debugging):
  1. Similarity: 0.488 | Source: knowledge_base/google-ai-agents-whitepaper.pdf
     Preview: Agents 5 September 2024 What is an agent? In its most 
     fundamental form, a Generative AI agent can be...
  2. Similarity: 0.428 | Source: knowledge_base/google-ai-agents-whitepaper.pdf
     Preview: Agents 39 September 2024 Figure 15. Sample end-to-end agent 
     architecture built on Vertex AI platform...
  3. Similarity: 0.374 | Source: knowledge_base/google-ai-agents-whitepaper.pdf
     Preview: Introduction 4 What is an agent? 5 The model 6 The tools 7 
     The orchestration layer 7 Agents vs. ...

🤖 Your Question: