Forem: Nanaji G

Running Ollama Locally for Enterprise PDF Classification from SharePoint

Nanaji G — Sun, 12 Oct 2025 08:03:29 +0000

Running Ollama Locally for Enterprise PDF Classification from SharePoint

Overview

In this comprehensive guide, we'll explore how to leverage Ollama running locally to classify enterprise PDFs stored in SharePoint. This solution provides a cost-effective, privacy-focused approach to document intelligence without relying on cloud-based AI services.

Why This Matters

Key Benefits:

🔒 Privacy First: Keep sensitive enterprise data on-premises
💰 Cost-Effective: No per-API-call charges
⚡ Performance: Low-latency processing for local documents
🎛️ Control: Full control over model selection and fine-tuning

🛠️ Prerequisites

Before we begin, ensure you have:

✅ Ollama installed locally (Download here)
✅ Python 3.8+ with pip
✅ SharePoint access with appropriate permissions
✅ Microsoft 365 credentials

📦 Required Libraries

Install the necessary Python packages:

pip install ollama
pip install office365-rest-python-client
pip install PyPDF2
pip install python-dotenv

Architecture Overview

Our solution follows this workflow:

Connect to SharePoint using Microsoft Graph API
Download PDFs from specified document library
Extract text content from PDFs
Classify documents using Ollama's LLM
Update metadata/tags in SharePoint

💻 Implementation

Step 1: Setting Up Ollama

First, pull a suitable model for classification:

# Pull a lightweight model
ollama pull llama2:7b

# Or for better accuracy
ollama pull llama2:13b

Step 2: SharePoint Connection

Create a config.py file for credentials:

import os
from dotenv import load_dotenv

load_dotenv()

SHAREPOINT_SITE = os.getenv('SHAREPOINT_SITE')
CLIENT_ID = os.getenv('CLIENT_ID')
CLIENT_SECRET = os.getenv('CLIENT_SECRET')
TENANT_ID = os.getenv('TENANT_ID')

Step 3: PDF Classification Script

Here's the main classification implementation:

import ollama
from office365.sharepoint.client_context import ClientContext
from office365.runtime.auth.client_credential import ClientCredential
import PyPDF2
import io

class PDFClassifier:
    def __init__(self, sharepoint_site, client_id, client_secret):
        self.site = sharepoint_site
        credentials = ClientCredential(client_id, client_secret)
        self.ctx = ClientContext(sharepoint_site).with_credentials(credentials)

    def extract_pdf_text(self, pdf_bytes):
        """Extract text from PDF bytes"""
        pdf_file = io.BytesIO(pdf_bytes)
        pdf_reader = PyPDF2.PdfReader(pdf_file)

        text = ""
        for page in pdf_reader.pages:
            text += page.extract_text()

        return text[:2000]  # Limit for prompt

    def classify_document(self, text_content):
        """Classify document using Ollama"""
        prompt = f"""
        Analyze the following document excerpt and classify it into ONE of these categories:
        - Financial Report
        - Legal Contract
        - Technical Documentation
        - Marketing Material
        - HR Document
        - General Correspondence

        Document:
        {text_content}

        Respond with ONLY the category name, nothing else.
        """

        response = ollama.chat(
            model='llama2:7b',
            messages=[{'role': 'user', 'content': prompt}]
        )

        return response['message']['content'].strip()

    def process_library(self, library_name):
        """Process all PDFs in a SharePoint library"""
        library = self.ctx.web.lists.get_by_title(library_name)
        items = library.items.get().execute_query()

        results = []

        for item in items:
            file = item.file.get().execute_query()

            if file.name.endswith('.pdf'):
                # Download PDF
                pdf_content = file.read()

                # Extract text
                text = self.extract_pdf_text(pdf_content)

                # Classify
                category = self.classify_document(text)

                results.append({
                    'file': file.name,
                    'category': category
                })

                print(f"✅ Classified: {file.name} → {category}")

        return results

Step 4: Running the Classifier

from config import *

# Initialize classifier
classifier = PDFClassifier(
    sharepoint_site=SHAREPOINT_SITE,
    client_id=CLIENT_ID,
    client_secret=CLIENT_SECRET
)

# Process documents
results = classifier.process_library('Documents')

# Display results
for result in results:
    print(f"📄 {result['file']}: {result['category']}")

Advanced Features

Custom Classification Categories

You can easily adapt the categories to your needs:

CATEGORIES = [
    "Invoice",
    "Purchase Order",
    "Compliance Report",
    "Employee Handbook",
    "Project Proposal"
]

Batch Processing with Progress Bar

from tqdm import tqdm

def process_library_with_progress(self, library_name):
    items = self.get_library_items(library_name)

    for item in tqdm(items, desc="Processing PDFs"):
        # Classification logic here
        pass

🔍 Best Practices

Performance Optimization

Batch Processing: Process documents in batches during off-hours
Caching: Cache classifications to avoid re-processing
Model Selection: Balance between accuracy and speed

Security Considerations

🔐 Use environment variables for credentials
🔐 Implement role-based access control
🔐 Enable audit logging for classification activities
🔐 Consider encryption for sensitive document content

Monitoring & Logging

Implement comprehensive logging:

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('classification.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

Common Issues & Solutions

Issue	Solution
Ollama not responding	Check if service is running: `ollama serve`
SharePoint auth fails	Verify app permissions in Azure AD
PDF extraction errors	Use `pdfplumber` as alternative to PyPDF2
Slow classification	Use smaller model or implement caching

Conclusion

This solution demonstrates how to:

✅ Leverage local LLMs for enterprise document classification

✅ Integrate with SharePoint seamlessly

✅ Maintain data privacy and control

✅ Build cost-effective AI solutions

🔗 Resources

Discussion

Have you implemented similar solutions? What challenges did you face? Share your experiences in the comments below!

Tags: #AI #MachineLearning #SharePoint #Python #Ollama #EnterpriseAI #DocumentClassification

OpenAI's AgentKit and Agent Builder: The Future of AI Automation Workflows

Nanaji G — Sun, 12 Oct 2025 07:47:01 +0000

I've been using n8n for quite a while now, building all kinds of automation workflows: some simple, some pretty complex. But after OpenAI announced AgentKit, and especially their new Agent Builder tool, I couldn't help but check it out. It's been getting a lot of buzz lately, and honestly, it looks like it could shake up the entire automation space.

In this post, I'll walk you through:

What AgentKit actually is
How Agent Builder works
A hands-on demo I built
A detailed comparison with n8n
Who should use what

Let's dive in!

What is OpenAI's AgentKit?

OpenAI's AgentKit is a new suite of tools built to help developers and teams create, deploy, and manage AI-powered agents with less friction.

Until now, building agentic workflows meant:

Juggling multiple tools
Writing complex orchestration logic
Spending too much time on frontend work

AgentKit changes that. It lets you design workflows visually and integrate agent-powered UIs much faster, thanks to three main components:

1. Agent Builder

A visual canvas where you can design multi-agent workflows with simple drag-and-drop actions. It comes with:

Built-in version control
Live previews
Safety guardrails to prevent errors, data leaks, or unsafe behavior

2. Connector Registry

Manages data and integrations across multiple workspaces and apps from one centralized place.

3. ChatKit

Handles the interface side, letting you embed conversational agents directly into your product without dealing with frontend complexity.

🎯 Evaluation Features

OpenAI is also rolling out new evaluation features:

Datasets
Trace grading
Automated prompt optimization
Third-party model support

All aimed at helping teams monitor and improve agent performance more systematically.

🛠️ How Does Agent Builder Work?

At the core of AgentKit is Agent Builder, a visual canvas where you can design multi-agent workflows with simple drag-and-drop actions.

Key Features:

🎨 Visual Workflow Design

Design complex multi-agent workflows visually without writing orchestration code.

🔄 Version Control

Built-in versioning lets you track changes, roll back, and iterate safely.

🛡️ Safety Guardrails

Modular guardrails for:

Masking PII (Personally Identifiable Information)
Jailbreak detection
Safe behavior enforcement

🔌 Connector Registry

Centralized management of integrations across workspaces.

💬 ChatKit Integration

Embed chat-based agent experiences directly into your product with zero frontend work.

Getting Started with Agent Builder

Time needed: 2 minutes

Here's how to access Agent Builder:

Log in to your OpenAI account on their official website
Visit the Agent Builder page and click on "Open Agent Builder"
Once in, click on "Create workflow"
Use the visual canvas to drag, drop, and connect components to create your agent workflows

💡 Demo: Building a Custom Agentic Workflow

I built a custom agentic workflow using OpenAI's Agent Builder to see firsthand how simple it is to create and deploy agents.

The Workflow:

I designed a workflow that:

Uses a FileSearchTool to read and search through my YouTube video transcripts
Answers user questions by intelligently searching those transcripts
Leverages GPT-5's reasoning capabilities to understand context and pull up accurate responses in seconds

How It Works:

# Sample Agent Builder Workflow Structure
agent:
  name: "YouTube Transcript Assistant"
  model: "gpt-5"
  tools:
    - FileSearchTool:
        source: "youtube_transcripts"
        search_mode: "semantic"
    - ResponseGenerator:
        temperature: 0.7
        max_tokens: 500

The Process:

User asks a question → The agent receives the query
FileSearchTool activates → Searches through transcript corpus
GPT-5 processes context → Understands intent and pulls relevant information
Agent responds → Delivers accurate, contextual answer

This approach illustrates the power of:

Agent Builder's drag-and-drop design
Built-in AI orchestration
Seamless tool integrations

All without heavy coding! 🎉

Sample Code: FileSearchTool Configuration

from agentkit import FileSearchTool, Agent

# Initialize FileSearchTool
file_search = FileSearchTool(
    name="transcript_search",
    files=["video1.txt", "video2.txt", "video3.txt"],
    embedding_model="text-embedding-3-large",
    search_strategy="hybrid"  # Combines semantic + keyword search
)

# Create agent with the tool
agent = Agent(
    name="YouTube Assistant",
    model="gpt-5",
    tools=[file_search],
    instructions="""
    You are a helpful assistant that answers questions about 
    YouTube video content by searching through transcripts.
    Always cite the specific video when answering.
    """
)

# Run the agent
response = agent.run("What topics were covered in the AI series?")
print(response)

Prompt Optimization Config

{
  "optimization": {
    "enabled": true,
    "strategy": "automated",
    "metrics": ["accuracy", "latency", "user_satisfaction"],
    "test_cases": [
      {
        "input": "What is discussed in video 3?",
        "expected_context": "video_3_transcript"
      }
    ],
    "guardrails": {
      "pii_masking": true,
      "jailbreak_detection": true,
      "content_filtering": "moderate"
    }
  }
}

AgentKit vs n8n: The Ultimate Comparison

While n8n is a mature and popular no-code/low-code automation platform with thousands of integrations and a strong community, Agent Builder takes a unique approach by integrating advanced AI agents with streamlined conversational UI and guardrails built-in.

Comparison Table

Feature	n8n	Agent Builder
Workflow Design	Visual, node-based drag & drop	Visual canvas with multi-agent orchestration, versioning
AI Integration	Limited, reliant on external APIs	Native AI agent orchestration with GPT-5 powered reasoning
Chat UI Embedding	Requires custom frontend development	Built-in ChatKit for embedding chat-based agent experiences
Safety & Guardrails	Manual implementation of data privacy and security	Modular guardrails for masking PII, jailbreak detection, and safe behavior
Data Connectors	Extensive integrations, community-built	Managed via Connector Registry, centralized control
Evaluation & Monitoring	Logs, executions, and some monitoring via plugins	Integrated evals with automated grading, prompt optimization, and trace grading
Version Control	Basic workflow versioning	Advanced built-in version control with rollback
Open Source	✅ Yes	❌ No (Proprietary)
Community Support	Large, active community	Growing, backed by OpenAI
Learning Curve	Moderate (familiar to automation users)	Low (AI-first, intuitive interface)

✅ Pros & Cons

Agent Builder

✅ Pros:

AI-native design - Built specifically for AI agent workflows
Zero frontend work - ChatKit handles UI embedding
Built-in safety - Guardrails for PII, jailbreak detection, etc.
Integrated evaluation - Automated prompt optimization and trace grading
Enterprise-ready - SSO, RBAC, audit logs included
GPT-5 integration - Advanced reasoning capabilities
Fast prototyping - Visual builder accelerates development

❌ Cons:

Proprietary - Not open source
Newer platform - Smaller community compared to n8n
OpenAI dependency - Tied to OpenAI ecosystem
Pricing uncertainty - Storage costs can add up
Limited integrations - Fewer third-party connectors (for now)

n8n

✅ Pros:

Open source - Full control and customization
Massive integration library - Thousands of pre-built nodes
Strong community - Active support and custom nodes
Self-hosting - Complete data control
Flexible pricing - Free for self-hosted
Mature platform - Battle-tested in production
Workflow versatility - Works for any automation, not just AI

❌ Cons:

Limited native AI - Requires external API integrations
Frontend work required - No built-in chat UI
Manual safety implementation - No built-in guardrails
Complex AI orchestration - More coding needed for agentic workflows
No integrated evals - Must build your own monitoring

💰 Pricing

AgentKit Pricing

Billing starts: November 1, 2025

Free Features:

Using Agent Builder to design and iterate (until you hit Run)
Self-hosting ChatKit (you only pay for model-token usage)
Enterprise controls: SSO, RBAC, and audit logs

Paid Features:

Storage: 1 GB free per account per month
Beyond 1 GB: $0.10 per GB-day
Model usage: Standard OpenAI API pricing applies

What This Means:

Prototyping and design are free
You only pay when running agents in production
Storage costs apply to ChatKit file and image uploads
Enterprise features included at no extra cost

n8n Pricing

Self-hosted: Free (open source)
Cloud: Starting at $20/month
Enterprise: Custom pricing

Who Should Use What?

Choose Agent Builder if you:

✅ Want to build AI-first workflows with minimal code
✅ Need embedded chat interfaces for your agents
✅ Require enterprise-grade safety guardrails out of the box
✅ Value integrated evaluation and prompt optimization
✅ Are building conversational AI experiences
✅ Want fast prototyping with visual tools
✅ Need native GPT-5 integration with advanced reasoning
✅ Prefer managed infrastructure over self-hosting

Best for: AI startups, SaaS products with conversational AI, teams building customer-facing agents, enterprise AI initiatives

Choose n8n if you:

✅ Need extensive third-party integrations (1000+ nodes)
✅ Value open-source flexibility and customization
✅ Want complete control with self-hosting
✅ Are building general automation workflows (not just AI)
✅ Have a limited budget (free self-hosted option)
✅ Prefer community-driven development
✅ Need to integrate with legacy systems
✅ Want to avoid vendor lock-in

Best for: Small businesses, automation enthusiasts, teams with DevOps expertise, general workflow automation, budget-conscious projects

🔥 My Take: Is It the End of n8n?

Short answer: No, but it's definitely competition.

Agent Builder is changing how we think about AI automation. Its visual, AI-native design, built-in safety guardrails, and integrated chat UI make it surprisingly easy to build intelligent agents without the usual technical hurdles.

n8n, on the other hand, still shines as a flexible, open-source automation platform with a massive integration library and a strong community behind it.

The Verdict:

If you're looking for streamlined, AI-first workflows with enterprise-level control, Agent Builder feels like the next big step.
If flexibility, community support, and open customization matter more to you, n8n still holds its ground.

💡 Pro Tip:

You could even use both! Use n8n for general automation and integrations, and Agent Builder for AI-specific agentic workflows. They can complement each other beautifully.

Final Thoughts

OpenAI's Agent Builder is a powerful new player in the automation space, especially for AI-powered workflows. Its combination of:

Visual workflow design
Native AI orchestration
Built-in chat UI
Safety guardrails
Integrated evaluation

...makes it a strong contender for teams building conversational AI experiences.

But n8n isn't going anywhere. Its open-source nature, massive integration ecosystem, and strong community make it irreplaceable for versatile automation needs.

What's Next?

I'll be diving deeper into both platforms, building more complex workflows, and sharing detailed tutorials. Stay tuned!

Have you tried Agent Builder or n8n? Drop your thoughts in the comments! 👇

📚 Related Resources

Tags: #ai #automation #openai #agents #n8n #agentbuilder #workflow #chatgpt #gpt5 #nocode

What automation tool are you using right now? Let me know in the comments! 💬