Nicholai/jan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mobile section updated

Browse Source
This commit is contained in:
Ramon Perez 2025-07-24 12:43:29 +10:00
parent ed610dcd4e
commit 101b4d700f
25 changed files with 1668 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

278
website/astro.config.mjs
View File

@ -3,125 +3,183 @@ import { defineConfig } from 'astro/config'
import starlight from '@astrojs/starlight'
import starlightThemeRapide from 'starlight-theme-rapide'
import starlightSidebarTopics from 'starlight-sidebar-topics'
import starlightVideos from 'starlight-videos'
// https://astro.build/config
export default defineConfig({
integrations: [
starlight({
title: '👋 Jan',
favicon: "jan2.png",
favicon: 'jan2.png',
plugins: [
starlightThemeRapide(),
starlightSidebarTopics([
starlightVideos(),
starlightSidebarTopics(
[
{
label: 'Jan',
link: '/',
icon: 'rocket',
items: [
{
label: 'HOW TO',
items: [
{
label: 'Install 👋 Jan',
collapsed: true,
autogenerate: { directory: 'jan/installation' },
},
{ label: 'Start Chatting', slug: 'jan/threads' },
{
label: 'Use Jan Models',
collapsed: true,
autogenerate: { directory: 'jan/jan-models' },
},
{ label: 'Assistants', slug: 'jan/assistants' },
],
},
{
label: 'TUTORIALS',
items: [
{ label: 'Translation', slug: 'jan/tutorials/translation' },
{
label: 'Creative Writing',
slug: 'jan/tutorials/creative-writing',
},
],
},
{
label: 'EXPLANATION',
items: [
{
label: 'Local AI Engine',
slug: 'jan/explanation/llama-cpp',
},
{
label: 'Model Parameters',
slug: 'jan/explanation/model-parameters',
},
],
},
{
label: 'ADVANCED',
items: [
{ label: 'Manage Models', slug: 'jan/manage-models' },
{ label: 'Model Context Protocol', slug: 'jan/mcp' },
{
label: 'MCP Examples',
collapsed: true,
autogenerate: { directory: 'jan/mcp-examples' },
},
],
},
{
label: 'REFERENCE',
items: [
{ label: 'Settings', slug: 'jan/settings' },
{ label: 'Jan Data Folder', slug: 'jan/data-folder' },
{ label: 'Troubleshooting', slug: 'jan/troubleshooting' },
{ label: 'Privacy Policy', slug: 'jan/privacy' },
],
},
],
},
{
label: 'Local Server',
link: '/local-server/',
icon: 'setting',
items: [
{ label: 'Server Setup', slug: 'local-server/api-server' },
{ label: 'Jan Data Folder', slug: 'local-server/data-folder' },
{ label: 'Settings', slug: 'local-server/settings' },
{ label: 'Llama.cpp', slug: 'local-server/llama-cpp' },
{
label: 'Integrations',
collapsed: true,
autogenerate: { directory: 'local-server/integrations' },
},
{
label: 'Troubleshooting',
slug: 'local-server/troubleshooting',
},
],
},
{
label: 'Products',
link: '/products/',
icon: 'forward-slash',
items: [
{ label: 'Overview', slug: 'products' },
{
label: 'Models',
autogenerate: { directory: 'products/models' },
},
{
label: 'Platforms',
autogenerate: { directory: 'products/platforms' },
},
{
label: 'Tools',
autogenerate: { directory: 'products/tools' },
},
],
},
{
label: 'Jan AI University',
link: '/university/',
icon: 'star',
id: 'university',
items: [
{ label: 'Welcome', slug: 'university' },
{
label: 'Getting Started Path',
items: [
{
label: 'Getting to Know Jan Series',
slug: 'university/getting-started/getting-to-know-jan',
},
{
label: 'Installation Guide',
slug: 'university/getting-started/installation',
},
{
label: 'Introduction Course',
slug: 'university/getting-started/introduction',
},
],
},
{
label: 'Advanced Path',
items: [
{
label: 'Using MCPs Tutorial Series',
slug: 'university/advanced/using-mcps',
},
{
label: 'API Integration',
slug: 'university/advanced/api-integration',
},
{
label: 'Performance Optimization',
slug: 'university/advanced/performance-optimization',
},
],
},
],
},
],
{
label: 'Jan',
link: '/',
icon: 'rocket',
items: [
{
label: 'HOW TO',
items: [
{
label: 'Install 👋 Jan',
collapsed: true,
autogenerate: { directory: 'jan/installation' },
},
{ label: 'Start Chatting', slug: 'jan/threads' },
{
label: 'Use Jan Models',
collapsed: true,
autogenerate: { directory: 'jan/jan-models' },
},
{ label: 'Assistants', slug: 'jan/assistants' },
],
},
{
label: 'TUTORIALS',
items: [
{ label: 'Translation', slug: 'jan/tutorials/translation' },
{
label: 'Creative Writing',
slug: 'jan/tutorials/creative-writing',
},
],
},
{
label: 'EXPLANATION',
items: [
{
label: 'Local AI Engine',
slug: 'jan/explanation/llama-cpp',
},
{
label: 'Model Parameters',
slug: 'jan/explanation/model-parameters',
},
],
},
{
label: 'ADVANCED',
items: [
{ label: 'Manage Models', slug: 'jan/manage-models' },
{ label: 'Model Context Protocol', slug: 'jan/mcp' },
{
label: 'MCP Examples',
collapsed: true,
autogenerate: { directory: 'jan/mcp-examples' },
},
],
},
{
label: 'REFERENCE',
items: [
{ label: 'Settings', slug: 'jan/settings' },
{ label: 'Jan Data Folder', slug: 'jan/data-folder' },
{ label: 'Troubleshooting', slug: 'jan/troubleshooting' },
{ label: 'Privacy Policy', slug: 'jan/privacy' },
],
},
],
},
{
label: 'Local Server',
link: '/local-server/',
icon: 'setting',
items: [
{ label: 'Server Setup', slug: 'local-server/api-server' },
{ label: 'Jan Data Folder', slug: 'local-server/data-folder' },
{ label: 'Settings', slug: 'local-server/settings' },
{ label: 'Llama.cpp', slug: 'local-server/llama-cpp' },
{
label: 'Integrations',
collapsed: true,
autogenerate: { directory: 'local-server/integrations' },
},
{
label: 'Troubleshooting',
slug: 'local-server/troubleshooting',
},
],
},
{
label: 'Products',
link: '/products/',
icon: 'forward-slash',
items: [
{ label: 'Overview', slug: 'products' },
{
label: 'Platforms',
autogenerate: { directory: 'products/platforms' },
},
{
label: 'Tools',
autogenerate: { directory: 'products/tools' },
},
{
label: 'Models',
autogenerate: { directory: 'products/models' },
},
],
},
]),
exclude: ['/example'],
topics: {
university: [
'/university/getting-started/what-is-jan',
'/university/getting-started/privacy-first-ai',
'/university/advanced/mcp-introduction',
'/university/advanced/search-integration-exa',
],
},
}
),
],
social: [
{

11
website/bun.lock
View File

@ -9,10 +9,13 @@
"sharp": "^0.34.2",
"starlight-sidebar-topics": "^0.6.0",
"starlight-theme-rapide": "^0.5.1",
"starlight-videos": "^0.3.0",
},
},
},
"packages": {
"@astro-community/astro-embed-youtube": ["@astro-community/astro-embed-youtube@0.5.6", "", { "dependencies": { "lite-youtube-embed": "^0.3.3" }, "peerDependencies": { "astro": "^2.0.0 || ^3.0.0-beta || ^4.0.0-beta || ^5.0.0-beta" } }, "sha512-/mRfCl/eTBUz0kmjD1psOy0qoDDBorVp0QumUacjFcIkBullYtbeFQ2ZGZ+3N/tA6cR/OIyzr2QA4dQXlY6USg=="],
"@astrojs/compiler": ["@astrojs/compiler@2.12.2", "", {}, "sha512-w2zfvhjNCkNMmMMOn5b0J8+OmUaBL1o40ipMvqcG6NRpdC+lKxmTi48DT8Xw0SzJ3AfmeFLB45zXZXtmbsjcgw=="],
"@astrojs/internal-helpers": ["@astrojs/internal-helpers@0.6.1", "", {}, "sha512-l5Pqf6uZu31aG+3Lv8nl/3s4DbUzdlxTWDof4pEpto6GUJNhhCbelVi9dEyurOVyqaelwmS9oSyOWOENSfgo9A=="],
@ -507,12 +510,16 @@
"is-wsl": ["is-wsl@3.1.0", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw=="],
"iso8601-duration": ["iso8601-duration@2.1.2", "", {}, "sha512-yXteYUiKv6x8seaDzyBwnZtPpmx766KfvQuaVNyPifYOjmPdOo3ajd4phDNa7Y5mTQGnXsNEcXFtVun1FjYXxQ=="],
"js-yaml": ["js-yaml@4.1.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="],
"kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],
"klona": ["klona@2.0.6", "", {}, "sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA=="],
"lite-youtube-embed": ["lite-youtube-embed@0.3.3", "", {}, "sha512-gFfVVnj6NRjxVfJKo3qoLtpi0v5mn3AcR4eKD45wrxQuxzveFJUb+7Cr6uV6n+DjO8X3p0UzPPquhGt0H/y+NA=="],
"longest-streak": ["longest-streak@3.1.0", "", {}, "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g=="],
"lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
@ -777,10 +784,14 @@
"space-separated-tokens": ["space-separated-tokens@2.0.2", "", {}, "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q=="],
"srt-parser-2": ["srt-parser-2@1.2.3", "", { "bin": { "srt-parser-2": "bin/index.js" } }, "sha512-dANP1AyJTI503H0/kXwRza+7QxDB3BqeFvEKTF4MI9lQcBe8JbRUQTKVIGzGABJCwBovEYavZ2Qsdm/s8XKz8A=="],
"starlight-sidebar-topics": ["starlight-sidebar-topics@0.6.0", "", { "dependencies": { "picomatch": "^4.0.2" }, "peerDependencies": { "@astrojs/starlight": ">=0.32.0" } }, "sha512-ysmOR7zaHYKtk18/mpW4MbEMDioR/ZBsisu9bdQrq0v9BlHWpW7gAdWlqFWO9zdv1P7l0Mo1WKd0wJ0UtqOVEQ=="],
"starlight-theme-rapide": ["starlight-theme-rapide@0.5.1", "", { "peerDependencies": { "@astrojs/starlight": ">=0.34.0" } }, "sha512-QRF6mzcYHLEX5UpUvOPXVVwISS298siIJLcKextoMLhXcnF12nX+IYJ0LNxFk9XaPbX9uDXIieSBJf5Pztkteg=="],
"starlight-videos": ["starlight-videos@0.3.0", "", { "dependencies": { "@astro-community/astro-embed-youtube": "^0.5.6", "hastscript": "^9.0.0", "iso8601-duration": "^2.1.2", "srt-parser-2": "^1.2.3", "unist-util-visit": "^5.0.0" }, "peerDependencies": { "@astrojs/starlight": ">=0.34.0" } }, "sha512-1yvFUEn3P+ZjuGr5COswQp14cZdIvsGjg9lqDIyW5clCrZaBiDMSNPLYngyQozaDbrublEp6/V9HbJR6sGnSOA=="],
"stream-replace-string": ["stream-replace-string@2.0.0", "", {}, "sha512-TlnjJ1C0QrmxRNrON00JvaFFlNh5TTG00APw23j74ET7gkQpTASi6/L2fuiav8pzK715HXtUeClpBTw2NPSn6w=="],
"string-width": ["string-width@7.2.0", "", { "dependencies": { "emoji-regex": "^10.3.0", "get-east-asian-width": "^1.0.0", "strip-ansi": "^7.1.0" } }, "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ=="],

3
website/package.json
View File

@ -14,6 +14,7 @@
"astro": "^5.6.1",
"sharp": "^0.34.2",
"starlight-sidebar-topics": "^0.6.0",
"starlight-theme-rapide": "^0.5.1"
"starlight-theme-rapide": "^0.5.1",
"starlight-videos": "^0.3.0"
}
}

BIN
website/src/assets/jan_mobile.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 136 KiB

BIN
website/src/assets/jan_mobile2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 36 KiB

BIN
website/src/assets/jan_mobile3.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 36 KiB

BIN
website/src/assets/jan_mobile4.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 37 KiB

BIN
website/src/assets/jan_mobile5.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 38 KiB

BIN
website/src/assets/jan_mobile6.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 38 KiB

BIN
website/src/assets/jan_mobile7.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 501 KiB

3
website/src/content.config.ts
View File

@ -1,7 +1,8 @@
import { defineCollection } from 'astro:content';
import { docsLoader } from '@astrojs/starlight/loaders';
import { docsSchema } from '@astrojs/starlight/schema';
import { videosSchema } from 'starlight-videos/schemas';
export const collections = {
docs: defineCollection({ loader: docsLoader(), schema: docsSchema() }),
docs: defineCollection({ loader: docsLoader(), schema: docsSchema({ extend: videosSchema }) }),
};

41
website/src/content/docs/products/index.mdx
View File

@ -3,31 +3,37 @@ title: Jan's Product Vision
description: AI that runs where you need it, how you need it
sidebar:
order: 0
banner:
content: Jan is OPEN SUPERINTELLIGENCE that you can Self Host! You can connect to the world while staying local.
---
import { Aside, Card, CardGrid } from '@astrojs/starlight/components';
Jan is evolving from a local AI application to a complete AI Agent platform. We combine models, applications, and tools to solve real problems.
Jan is evolving from a local AI application to a complete full-stack AI solution that you can
self-host. This includes models, applications, and tools to solve real problems.
## What We're Building
**Jan Agent** = Jan Models + Jan Application + Jan Tools
Unlike other AI assistants that are just wrappers around Claude or GPT-4, Jan provides:
- Our own models optimized for local and private use
Unlike other AI assistants that do specific tasks with one model or have many models with
a myriad of solutions, Jan provides:
- Our own models optimized for local and private use. As of now, we have Jan Nano in 2 flavors and
Lucy but more are coming soon
- Applications that work across all your devices
- Tools that actually get things done
## Two Modes, One Experience
### Local (Incognito) Mode
Your AI runs entirely on your device. Complete privacy, no internet required.
This mode allows you to run AI models entirely on your device, giving you complete
privacy with no internet required.
### Cloud Mode
### Cloud Mode
Connect to more powerful models when needed - either self-hosted or via jan.ai.
<Aside type="note">
<Aside type="tip" title="We understand that...">
Users shouldn't need to understand models, APIs, or technical details. Just choose Local for privacy or Cloud for power.
</Aside>
@ -40,22 +46,22 @@ Users shouldn't need to understand models, APIs, or technical details. Just choo
- Optional cloud connection
- Powers other devices
</Card>
<Card title="Server" icon="server">
<Card title="Server" icon="bars">
**Coming Soon**
- Self-hosted for teams
- 5-10 concurrent users
- Your own private cloud
</Card>
<Card title="Mobile" icon="mobile">
<Card title="Mobile" icon="phone">
**In Development**
- Connect to Desktop/Server
- Local mode with Jan Nano
- Same experience everywhere
</Card>
<Card title="jan.ai Web" icon="globe">
<Card title="jan.ai Web" icon="up-arrow">
**Beta Launch Soon**
- SaaS version of Jan Server
- Default for mobile/desktop cloud mode
@ -66,7 +72,12 @@ Users shouldn't need to understand models, APIs, or technical details. Just choo
## Our Product Principles
### It Just Works
Open Jan, start chatting. No setup wizards, no API keys, no model selection. We handle the complexity.
1. Open Jan, start chatting.
2. Onboarding is fully available but optional.
3. Setting up an API key is optional
4. Selecting a local model is optional.
> We handle the complexity.
### Privacy First, Cloud When Needed
Start with complete privacy by default. Add cloud capabilities only when you choose to.
@ -79,7 +90,7 @@ Users want answers, not configuration options. Power users can dig deeper, but i
| Feature | Other AI Assistants | Jan |
|---------|---------------------|-----|
| Models | Wrapper around Claude/GPT | Our own models + others |
| Privacy | Your data on their servers | Your data stays yours |
| Dual mode | Your data on their servers | Your data stays yours |
| Deployment | Cloud only | Local, self-hosted, or cloud |
| Cost | Subscription forever | Free locally, pay for cloud |
@ -90,7 +101,7 @@ Users want answers, not configuration options. Power users can dig deeper, but i
- Basic cloud connections
- Developer-friendly API
### Next 6 Months
### Next 6 Months
- Simplified Local/Cloud modes
- jan.ai cloud service
- Mobile apps

98
website/src/content/docs/products/platforms/mobile.mdx
View File

@ -9,24 +9,36 @@ import { Aside, Card, CardGrid } from '@astrojs/starlight/components';
Jan Mobile brings the same AI experience to your phone. Connect to your desktop, your server, or run models locally.
![Jan Mobile](../../../../assets/jan_mobile.png)
<Aside type="note">
Coming Q1 2026. Join the waitlist at [jan.ai/mobile](https://jan.ai/mobile).
Coming Q4 2025. Sign up here to get a notification when it's available [Newsletter](https://jan.ai/mobile).
</Aside>
## How It Works
Jan Mobile adapts to your situation:
| At Home | At Work | On the Go |
|---------|---------|-----------|
| Connect to your Jan Desktop over WiFi | Connect to company Jan Server | Run Jan Nano locally on your phone |
At Home, you can connect to your Jan Desktop over WiFi
No configuration needed. It just works.
![Jan Mobile Home](../../../../assets/jan_mobile2.png)
At Work, you can connect to your company Jan Server
![Jan Mobile Home](../../../../assets/jan_mobile3.png)
On the Go, you can run Jan Nano on your phone or talk to your favourite cloud-based model
![Jan Mobile Home](../../../../assets/jan_mobile4.png)
**No configuration needed. It just works.**
## Three Modes, One Experience
### Desktop Mode
When you're near your computer, your phone uses its models and processing power.
When you're near your computer at home, you an toggle phone uses its models and processing power.
```
Your Phone → WiFi → Your Desktop → Response
@ -71,33 +83,24 @@ Your Phone → Jan Nano (6GB) → Response
The app automatically switches between modes based on what's available. You don't need to do anything.
</Aside>
## Device Requirements
### iOS
- iPhone 11 or newer
- iOS 15+
- 8GB storage for Local Mode
### Android
- 8GB RAM minimum
- Android 11+
- 8GB storage for Local Mode
## Key Features
<CardGrid>
<Card title="Seamless Switching" icon="refresh">
Move from home to office to airplane. Jan adapts automatically.
</Card>
<Card title="Seamless Switching" icon="random">
Move from home to office to airplane. One-click and Jan adapts immediately.
<Card title="Voice First" icon="microphone">
Talk to Jan naturally. Responses can be spoken too.
</Card>
![Jan Mobile Home](../../../../assets/jan_mobile6.png)
</Card>
<Card title="Sync Everything" icon="sync">
Conversations, settings, and preferences follow you across devices.
</Card>
</CardGrid>
<Card title="Voice First" icon="phone">
Talk to Jan naturally. Responses can be spoken too.
![Jan Mobile Home](../../../../assets/jan_mobile5.png)
</Card>
<Card title="Sync Everything" icon="up-arrow">
Conversations, settings, and preferences follow you across devices.
![Jan Mobile Home](../../../../assets/jan_mobile7.png)
</Card>
## Privacy & Security
@ -112,26 +115,10 @@ The app automatically switches between modes based on what's available. You don'
- No cloud backups without permission
- Clear data anytime
## Common Questions
### Do I need to download models to my phone?
No. In Desktop or Server mode, models run remotely. For Local Mode, Jan Nano downloads automatically when needed (6GB).
### How fast is Local Mode?
On modern phones, expect 30-50 tokens per second. Good enough for most conversations.
### Can I use it without Jan Desktop?
Yes. Use Local Mode or connect to jan.ai (when available).
### Will it drain my battery?
Desktop/Server modes use minimal battery. Local Mode is like using any intensive app - noticeable but manageable.
### Is it the same as desktop?
Same Jan, smaller screen. All the privacy, none of the complexity.
## Why Mobile Matters
Your phone is with you always. Your AI assistant should be too. But that doesn't mean sacrificing privacy or control.
Your phone is with you always. Your AI assistant should be too. But that doesn't mean sacrificing
privacy or control.
Jan Mobile proves you can have:
- Powerful AI anywhere
@ -141,17 +128,14 @@ Jan Mobile proves you can have:
## Coming Features
### Launch (Q1 2026)
### Launch (Q4 2025)
- iOS and Android apps
- Basic chat interface
- Three connection modes
- Voice input
### Post-Launch
- Widget support
- Siri/Assistant integration
- voice input
- Background sync
- Notification summaries
<Aside type="note">
Jan Mobile uses Tauri for native performance with a small app size (~50MB).
@ -168,15 +152,9 @@ Most mobile AI apps are just cloud wrappers. Jan Mobile is different:
| Privacy | Your data in cloud | Your data stays yours |
| Cost | Monthly subscription | Free with your hardware |
## Get Ready
While you wait for Jan Mobile:
## While you wait for Jan Mobile:
1. **Set up Jan Desktop** - It will power your mobile experience
2. **Try jan.ai** - Get familiar with the interface
3. **Join the waitlist** - Be first to know when it launches
3. **Join our newsletter** - Be first to know when it launches
4. **Tell us what you need** - Shape the mobile experience
---
[Join Mobile Waitlist](https://jan.ai/mobile) | [Desktop Download](https://jan.ai/download) | [Discord Community](https://discord.gg/jan)

139
website/src/content/docs/university/advanced/api-integration.mdx Normal file
View File

@ -0,0 +1,139 @@
---
title: Jan API Integration for Developers
description: Learn to build applications using Jan's local server API
video:
type: video
link: https://www.youtube.com/watch?v=L_jWHffIx5E
duration: 420
---
import { List } from 'starlight-videos/components';
# Jan API Integration for Developers
Ready to build applications powered by Jan? In this advanced course, you'll learn how to integrate Jan's local server API into your own applications, enabling you to create AI-powered tools and services.
## What You'll Learn
- Understanding Jan's OpenAI-compatible API
- Setting up the local server for development
- Making your first API calls
- Authentication and security considerations
- Building a simple AI-powered application
- Best practices for production deployment
## Prerequisites
<List title="Developer Requirements" variant="caution" icon="warning">
- Jan installed and working properly
- Downloaded at least one model
- Local server enabled in Jan settings
- Basic programming knowledge (any language)
- Understanding of REST APIs and HTTP requests
- Familiarity with JSON data format
</List>
## Course Outline
### 1. API Overview
- Jan's local server architecture
- OpenAI compatibility layer
- Available endpoints and methods
- Rate limiting and resource management
### 2. Development Setup
- Enabling the local server
- Configuring ports and security
- Testing connectivity with curl
- Using API testing tools like Postman
### 3. Core API Operations
- Chat completions endpoint
- Streaming responses
- Model management
- System monitoring
### 4. Building Your First App
We'll build a simple chat application that demonstrates:
- Connecting to Jan's API
- Sending messages and receiving responses
- Handling streaming responses
- Error handling and reconnection logic
### 5. Advanced Integration Patterns
- Async/await patterns for better performance
- Caching strategies for repeated queries
- Integration with popular frameworks (Express.js, FastAPI, etc.)
- WebSocket integration for real-time apps
## Code Examples
### Basic Python Integration
```python
import requests
import json
def chat_with_jan(message):
url = "http://localhost:1337/v1/chat/completions"
headers = {"Content-Type": "application/json"}
data = {
"model": "your-model-name",
"messages": [{"role": "user", "content": message}]
}
response = requests.post(url, headers=headers, json=data)
return response.json()
```
### JavaScript/Node.js Example
```javascript
const axios = require('axios');
async function chatWithJan(message) {
const response = await axios.post('http://localhost:1337/v1/chat/completions', {
model: 'your-model-name',
messages: [{ role: 'user', content: message }]
});
return response.data.choices[0].message.content;
}
```
## Security Considerations
- Keeping API endpoints local and secure
- Managing API keys and authentication
- Rate limiting to prevent abuse
- Monitoring resource usage
- Backup and recovery strategies
## Real-World Applications
Examples of what you can build:
- **Customer Service Bots**: Automated support using your data
- **Content Generation Tools**: AI-powered writing assistants
- **Code Analysis Tools**: Automated code review and suggestions
- **Personal Assistants**: Custom AI helpers for specific tasks
## Production Deployment
- Scaling considerations for multiple users
- Load balancing strategies
- Monitoring and logging
- Error handling and fallback mechanisms
- Performance optimization techniques
## Next Steps
After completing this course, consider exploring:
- **Custom Model Integration**: Adding your own fine-tuned models
- **Multi-Modal Applications**: Integrating with vision and audio models
- **Enterprise Scaling**: Deploying Jan for team use
## Resources
- [Jan API Documentation](https://jan.ai/api-reference)
- [Example Applications GitHub Repository](https://github.com/menloresearch/jan-examples)
- [Community Discord](https://discord.gg/qSwXFx6Krr) for developer support
Ready to start building? Watch the video above and follow along with the code examples!

200
website/src/content/docs/university/advanced/mcp-introduction.mdx Normal file
View File

@ -0,0 +1,200 @@
---
title: MCP Introduction & Setup
description: Understanding Model Context Protocol and getting it configured
video:
type: collection-video
link: https://www.youtube.com/watch?v=L_jWHffIx5E
duration: 480
collection: using-mcps
order: 1
difficulty: Intermediate
---
import { List, Quiz, QuizOption } from 'starlight-videos/components';
# MCP Introduction & Setup
Welcome to the world of Model Context Protocol! This foundational video explains what MCPs are, why they're revolutionary for AI applications, and how to get them set up in your Jan installation.
<List title="Prerequisites" variant="caution" icon="warning">
- Jan installed and working properly
- Downloaded at least one model
- Basic understanding of APIs and web services
- Administrative access to your computer
</List>
## What You'll Learn
- **MCP Fundamentals**: What MCPs are and how they work
- **Architecture Overview**: How MCPs connect AI to external systems
- **Setup Process**: Enabling MCP support in Jan
- **Configuration Basics**: Understanding MCP settings and options
- **Verification**: Testing that MCPs are working correctly
## Understanding MCPs
### What is Model Context Protocol?
Model Context Protocol is a standardized way for AI models to interact with external tools, APIs, and services. Think of it as a bridge that allows your AI to:
- **Access Real-Time Data**: Get current information from the web
- **Execute Code**: Run programs and scripts safely
- **Interact with APIs**: Connect to third-party services
- **Process Files**: Work with documents and media
- **Perform Actions**: Make changes to external systems
### Why MCPs Matter
- **Extended Capabilities**: Go beyond text generation
- **Real-World Integration**: Connect AI to your existing tools
- **Customization**: Build workflows specific to your needs
- **Standardization**: Use a consistent protocol across services
## MCP Architecture Deep Dive
### Core Components
1. **MCP Client**: Jan's built-in MCP handler
2. **MCP Server**: External services that provide capabilities
3. **Transport Layer**: How messages are exchanged
4. **Schema Definition**: How capabilities are described
### Communication Flow
```
Jan (MCP Client) ←→ Transport ←→ MCP Server ←→ External Service
```
### Security Model
- **Sandboxed Execution**: MCPs run in isolated environments
- **Permission System**: Granular control over what MCPs can access
- **Authentication**: Secure connection to external services
- **Audit Logging**: Track all MCP interactions
## Step-by-Step Setup
### 1. Check Jan Version
<List title="Version Requirements" variant="note" icon="information">
- Jan 0.5.0 or later required
- Latest version recommended for best features
- Check Help → About Jan for your version
</List>
### 2. Enable MCP Support
- Navigate to Jan Settings
- Find the "Extensions" or "MCP" section
- Toggle "Enable Model Context Protocol"
- Restart Jan if prompted
### 3. Configure MCP Directory
- Set the directory where MCP servers will be stored
- Choose a location with adequate disk space
- Ensure Jan has read/write permissions
### 4. Initial MCP Installation
- Browse the MCP marketplace
- Install a simple MCP (like system info)
- Verify the installation completed successfully
### 5. Test Your Setup
- Start a new conversation
- Try using the installed MCP
- Verify responses include MCP data
## Configuration Options
### MCP Settings Overview
- **Enable/Disable**: Global MCP toggle
- **Server Directory**: Where MCP servers are stored
- **Timeout Settings**: How long to wait for MCP responses
- **Security Settings**: Permission and access controls
- **Logging Level**: How much detail to log
### Performance Tuning
- **Concurrent Connections**: How many MCPs can run simultaneously
- **Memory Limits**: Resource constraints for MCP servers
- **Cache Settings**: Storing MCP responses for faster access
- **Network Configuration**: Proxy and firewall settings
## Common Setup Issues
### Problem: MCPs Not Loading
**Solutions:**
- Check Jan version compatibility
- Verify MCP directory permissions
- Review Jan logs for error messages
- Restart Jan after configuration changes
### Problem: Connection Timeouts
**Solutions:**
- Increase timeout settings
- Check internet connection
- Verify API credentials
- Test with simpler MCPs first
### Problem: Permission Errors
**Solutions:**
- Run Jan as administrator (if needed)
- Check folder permissions
- Review security software blocking
- Verify antivirus exceptions
## Verification Checklist
<List title="Setup Verification" variant="success" icon="approve-check">
- MCP toggle is enabled in settings
- MCP directory is configured and accessible
- At least one MCP is installed successfully
- MCP responds correctly in conversations
- No error messages in Jan logs
</List>
## What's Next?
Once your MCP setup is complete, you're ready for **Enabling Your First MCP**, where we'll walk through installing and configuring your first real-world MCP integration.
## Pro Tips
- Start with simple MCPs before moving to complex integrations
- Keep your MCPs updated for security and functionality
- Monitor resource usage when running multiple MCPs
- Join the Discord community for MCP-specific support
Ready to bridge the gap between AI and the real world? Let's get MCPs running in your Jan installation!
## MCP Fundamentals Quiz
Test your understanding of Model Context Protocol concepts:
<Quiz title="What does MCP stand for?" variant="note">
<QuizOption>Model Computing Protocol</QuizOption>
<QuizOption correct>Model Context Protocol</QuizOption>
<QuizOption>Machine Context Processing</QuizOption>
<QuizOption>Multi-Channel Protocol</QuizOption>
</Quiz>
<Quiz title="What can MCPs enable your AI to do?" multiple variant="tip">
<QuizOption correct>Access real-time data from the web</QuizOption>
<QuizOption>Make AI responses faster</QuizOption>
<QuizOption correct>Execute code safely</QuizOption>
<QuizOption correct>Interact with APIs and external services</QuizOption>
<QuizOption>Reduce memory usage</QuizOption>
</Quiz>
<Quiz title="What is the minimum Jan version required for MCP support?" variant="caution">
<QuizOption>Jan 0.3.0</QuizOption>
<QuizOption>Jan 0.4.0</QuizOption>
<QuizOption correct>Jan 0.5.0</QuizOption>
<QuizOption>Jan 1.0.0</QuizOption>
</Quiz>
<Quiz title="In the MCP architecture, what role does Jan play?" variant="success">
<QuizOption>MCP Server</QuizOption>
<QuizOption correct>MCP Client</QuizOption>
<QuizOption>Transport Layer</QuizOption>
<QuizOption>External Service</QuizOption>
</Quiz>
<Quiz title="What should you do if MCPs are not loading properly?" multiple variant="caution">
<QuizOption correct>Check Jan version compatibility</QuizOption>
<QuizOption>Reinstall Jan completely</QuizOption>
<QuizOption correct>Verify MCP directory permissions</QuizOption>
<QuizOption correct>Review Jan logs for error messages</QuizOption>
<QuizOption>Disable all other extensions</QuizOption>
</Quiz>

194
website/src/content/docs/university/advanced/performance-optimization.mdx Normal file
View File

@ -0,0 +1,194 @@
---
title: Performance Optimization Masterclass
description: Get maximum performance from Jan on your hardware
video:
type: video
link: https://www.youtube.com/watch?v=kJQP7kiw5Fk
duration: 480
---
import { List } from 'starlight-videos/components';
# Performance Optimization Masterclass
Ready to squeeze every bit of performance from your Jan setup? This advanced course covers everything you need to know about optimizing Jan for maximum speed, efficiency, and throughput on your specific hardware configuration.
## What You'll Learn
- Hardware optimization strategies
- Model selection for performance
- Memory management techniques
- GPU acceleration setup
- System-level optimizations
- Benchmarking and monitoring tools
## Prerequisites
<List title="Optimization Requirements" variant="tip" icon="star">
- Jan installed and running smoothly
- Downloaded models of different sizes for testing
- Basic understanding of computer hardware
- Administrative access to your system
- Benchmarking tools installed (optional)
- Willingness to experiment with settings
</List>
## Course Sections
### 1. Hardware Assessment
- Identifying your system's bottlenecks
- CPU vs GPU performance characteristics
- Memory and storage considerations
- Thermal management for sustained performance
### 2. Model Optimization
- Quantization levels and their trade-offs
- Model size vs. speed considerations
- Context length optimization
- Batch processing techniques
### 3. System Configuration
- Operating system optimizations
- Process priority and CPU affinity
- Memory allocation strategies
- Disk I/O optimization
### 4. GPU Acceleration
- CUDA setup for NVIDIA cards
- Vulkan configuration for AMD/Intel
- Multi-GPU configurations
- Memory management on GPU
## Performance Metrics to Track
### Speed Metrics
- **Tokens per second**: Raw generation speed
- **Time to first token**: Response latency
- **Context processing speed**: How fast Jan ingests your prompt
### Resource Metrics
- **CPU utilization**: Processor efficiency
- **Memory usage**: RAM and VRAM consumption
- **Temperature monitoring**: Thermal throttling prevention
- **Power consumption**: Energy efficiency
## Optimization Strategies by Hardware Type
### High-End Gaming PC
- Maximize GPU utilization
- Large model recommendations
- Multi-threading optimization
- Overclocking considerations
### MacBook (Apple Silicon)
- Unified memory advantages
- Model recommendations for M1/M2/M3
- Power efficiency settings
- Thermal management
### Business Laptop
- Battery optimization
- Smaller model selection
- CPU-only optimization
- Background process management
### Server/Workstation
- Multi-model serving
- Concurrent user optimization
- Enterprise-grade monitoring
- Cluster configuration basics
## Advanced Techniques
### Model Quantization Deep Dive
- Understanding Q4, Q6, Q8 quantization
- Custom quantization for your use case
- Quality vs. speed trade-offs
- Measuring quantization impact
### Memory Management
- Model offloading strategies
- Context caching optimization
- Garbage collection tuning
- Memory-mapped file usage
### Parallel Processing
- Multi-threaded inference
- Batch processing optimization
- Pipeline parallelism
- Model parallelism techniques
## Benchmarking Your Setup
We'll use these tools to measure performance:
- Built-in Jan performance metrics
- System monitoring tools
- Custom benchmarking scripts
- A/B testing different configurations
## Common Performance Issues
### Problem: Slow Response Times
**Solutions**:
- Reduce model size
- Increase context cache
- Optimize prompt length
- Check system resources
### Problem: High Memory Usage
**Solutions**:
- Enable model offloading
- Reduce context length
- Close unnecessary applications
- Consider smaller model variants
### Problem: Inconsistent Performance
**Solutions**:
- Monitor thermal throttling
- Check background processes
- Optimize power settings
- Update drivers and software
## Real-World Case Studies
### Case Study 1: Content Creator Setup
- Hardware: RTX 4080, 32GB RAM
- Use case: Long-form content generation
- Optimization: Large model with GPU acceleration
- Results: 45 tokens/sec sustained
### Case Study 2: Developer Workstation
- Hardware: MacBook Pro M2 Max
- Use case: Code assistance and documentation
- Optimization: Balanced model for quick responses
- Results: Sub-200ms first token time
### Case Study 3: Enterprise Deployment
- Hardware: Server with multiple GPUs
- Use case: Team collaboration platform
- Optimization: Multi-model serving with load balancing
- Results: 20+ concurrent users supported
## Monitoring and Maintenance
- Setting up performance dashboards
- Automated alert systems
- Regular performance audits
- Update and maintenance schedules
## Advanced Hardware Considerations
- NVMe SSD requirements for large models
- Network optimization for remote deployments
- Custom cooling solutions
- Professional workstation recommendations
## Next Level: Custom Builds
For ultimate performance:
- Building a dedicated Jan server
- Custom GPU clusters
- Edge deployment optimization
- Cloud vs. on-premise trade-offs
Ready to unlock Jan's full potential? Follow along with the video and transform your Jan experience from good to exceptional!

269
website/src/content/docs/university/advanced/search-integration-exa.mdx Normal file
View File

@ -0,0 +1,269 @@
---
title: Search Integration with Exa
description: Connect real-time web search capabilities to your AI conversations
video:
type: collection-video
link: https://www.youtube.com/watch?v=kJQP7kiw5Fk
duration: 360
collection: using-mcps
order: 3
difficulty: Intermediate
---
import { List, Quiz, QuizOption } from 'starlight-videos/components';
# Search Integration with Exa
Transform your AI conversations with real-time web search capabilities! This video shows you how to integrate Exa search into Jan, giving your AI access to current information from across the internet.
<List title="Prerequisites" variant="caution" icon="warning">
- Jan installed with MCP support enabled
- Downloaded and activated at least one model
- Exa API account and key (free tier available)
- Basic understanding of API authentication
</List>
## What You'll Learn
- **Exa Overview**: What makes Exa different from traditional search
- **API Setup**: Getting your Exa account and API key
- **MCP Installation**: Installing the Exa MCP server
- **Configuration**: Setting up authentication and preferences
- **Usage Patterns**: How to effectively use search in conversations
- **Troubleshooting**: Common issues and solutions
## About Exa Search
### What is Exa?
Exa is a search engine built specifically for AI applications. Unlike traditional search engines that return web pages, Exa provides:
- **Semantic Search**: Understanding context and meaning
- **Structured Results**: Clean, AI-friendly data formats
- **Real-Time Information**: Current data and recent developments
- **High-Quality Sources**: Curated, reliable information
### Why Exa for AI?
- **AI-Native Design**: Built for AI consumption
- **Better Context**: More relevant results for AI reasoning
- **Cleaner Data**: Less noise, more signal
- **Developer-Friendly**: Easy integration with MCPs
## Setting Up Exa
### 1. Create Your Exa Account
- Visit [Exa's website](https://exa.ai)
- Sign up for a free developer account
- Verify your email address
- Access your dashboard
### 2. Generate API Key
- Navigate to API Keys section
- Create a new API key
- Copy and securely store your key
- Note your usage limits and pricing
<List title="Security Reminder" variant="danger" icon="warning">
- Never share your API key publicly
- Store it securely in Jan's configuration
- Monitor your usage to avoid unexpected charges
- Regenerate keys if compromised
</List>
### 3. Understand Usage Limits
- **Free Tier**: Usually includes limited searches per month
- **Rate Limits**: Requests per second/minute restrictions
- **Data Limits**: Amount of data returned per search
- **Commercial Use**: Check terms for business applications
## Installing Exa MCP
### Installation Process
1. Open Jan settings
2. Navigate to MCP/Extensions section
3. Search for "Exa" in the MCP marketplace
4. Click "Install" on the Exa Search MCP
5. Wait for installation to complete
### Configuration Steps
1. **API Key Setup**:
- Enter your Exa API key
- Test the connection
- Save configuration
2. **Search Preferences**:
- Default result count (5-10 recommended)
- Content types to include/exclude
- Language preferences
- Date range filters
3. **Security Settings**:
- Enable/disable automatic searches
- Set conversation context limits
- Configure usage monitoring
## Using Exa in Conversations
### Basic Search Queries
```
"What are the latest developments in renewable energy?"
"Find recent research on machine learning optimization"
"Search for current news about Jan AI"
```
### Advanced Search Techniques
```
"Search for academic papers about transformer models published in 2024"
"Find technical documentation for Python FastAPI framework"
"Look up recent startup funding in the AI space"
```
### Search with Context
```
"I'm working on a climate change project. Search for the latest
IPCC report findings and recent renewable energy breakthroughs."
```
## Best Practices
### Effective Search Strategies
<List title="Search Tips" variant="tip" icon="star">
- Be specific about what information you need
- Include time constraints ("recent", "2024", etc.)
- Specify source types (academic, news, documentation)
- Ask for comparisons between multiple sources
- Request summaries of complex topics
</List>
### Query Optimization
- **Specific Keywords**: Use precise terminology
- **Context Setting**: Provide background for better results
- **Result Filtering**: Ask for specific types of content
- **Follow-up Questions**: Build on previous search results
## Real-World Use Cases
### Research & Analysis
```
User: "Search for recent studies on the effectiveness of remote work"
AI: [Searches and finds recent research papers and surveys]
AI: "Based on recent studies I found, remote work effectiveness varies..."
```
### Current Events & News
```
User: "What's happening with AI regulation in the EU?"
AI: [Searches for latest EU AI Act developments]
AI: "The latest developments in EU AI regulation include..."
```
### Technical Documentation
```
User: "Find the latest API documentation for OpenAI's models"
AI: [Searches for current API docs and changes]
AI: "Here's what I found about OpenAI's latest API updates..."
```
### Market Research
```
User: "Search for recent funding rounds in the AI startup space"
AI: [Finds recent investment news and startup funding data]
AI: "Recent AI startup funding shows several interesting trends..."
```
## Monitoring and Management
### Usage Tracking
- Monitor your API usage in Exa dashboard
- Set up alerts for usage limits
- Track costs and billing
- Optimize query frequency
### Performance Optimization
- **Cache Results**: Avoid duplicate searches
- **Batch Queries**: Combine related searches
- **Filter Results**: Request only needed information
- **Rate Limiting**: Respect API limits
## Troubleshooting Common Issues
### Problem: Search Results Not Appearing
**Solutions:**
- Check API key configuration
- Verify internet connection
- Test API key in Exa dashboard
- Review Jan logs for error messages
### Problem: Poor Search Quality
**Solutions:**
- Refine search queries with more specific terms
- Adjust result count settings
- Try different search approaches
- Provide more context in queries
### Problem: API Limit Exceeded
**Solutions:**
- Monitor usage more closely
- Upgrade to higher tier if needed
- Optimize search frequency
- Cache results to avoid duplicate searches
## Advanced Features
### Custom Search Domains
- Restrict searches to specific websites
- Academic database integration
- News source filtering
- Domain-specific search patterns
### Result Processing
- Automatic summarization
- Fact checking and verification
- Cross-referencing multiple sources
- Citation and source tracking
## What's Next?
Now that you have real-time search capabilities, you're ready for **Data Analysis with E2B**, where we'll add code execution and data processing capabilities to your AI toolkit.
Ready to give your AI real-time knowledge of the world? Let's connect Exa search to Jan!
## Exa Integration Knowledge Check
Test your understanding of Exa search integration:
<Quiz title="What makes Exa different from traditional search engines?" variant="tip">
<QuizOption>It's faster than Google</QuizOption>
<QuizOption>It's completely free</QuizOption>
<QuizOption correct>It's built specifically for AI applications with semantic search</QuizOption>
<QuizOption>It doesn't require an API key</QuizOption>
</Quiz>
<Quiz title="What do you need to set up Exa search integration?" multiple variant="caution">
<QuizOption correct>Jan with MCP support enabled</QuizOption>
<QuizOption correct>Exa API account and key</QuizOption>
<QuizOption>Google API credentials</QuizOption>
<QuizOption correct>Downloaded and activated at least one model</QuizOption>
<QuizOption>Premium Jan subscription</QuizOption>
</Quiz>
<Quiz title="Which search query is most effective for getting recent information?" variant="note">
<QuizOption>"Tell me about renewable energy"</QuizOption>
<QuizOption correct>"Search for recent studies on renewable energy published in 2024"</QuizOption>
<QuizOption>"What is renewable energy?"</QuizOption>
<QuizOption>"Renewable energy information"</QuizOption>
</Quiz>
<Quiz title="What should you do to avoid API limit issues?" multiple variant="success">
<QuizOption correct>Monitor your API usage in Exa dashboard</QuizOption>
<QuizOption>Make as many searches as possible quickly</QuizOption>
<QuizOption correct>Cache results to avoid duplicate searches</QuizOption>
<QuizOption correct>Set up alerts for usage limits</QuizOption>
<QuizOption>Share your API key with others</QuizOption>
</Quiz>
<Quiz title="If search results are not appearing, what should you check first?" variant="caution">
<QuizOption>Your internet speed</QuizOption>
<QuizOption correct>API key configuration</QuizOption>
<QuizOption>Jan version number</QuizOption>
<QuizOption>Computer memory</QuizOption>
</Quiz>

109
website/src/content/docs/university/advanced/using-mcps.mdx Normal file
View File

@ -0,0 +1,109 @@
---
title: Using MCPs (Model Context Protocol)
description: Master Jan's MCP system to extend AI capabilities with external tools and services
video:
type: collection
collection: using-mcps
---
import { List } from 'starlight-videos/components';
# Using MCPs (Model Context Protocol)
Model Context Protocol (MCP) is Jan's powerful system for connecting AI models to external tools, APIs, and services. This advanced tutorial series teaches you how to enable, configure, and maximize MCPs to dramatically expand your AI's capabilities.
<List title="Prerequisites" variant="caution" icon="warning">
- Jan installed and working
- Downloaded at least one model
- MCP feature enabled in Jan settings
- Basic understanding of APIs and web services
- Some technical comfort with configuration files
</List>
## What You'll Master
By completing this collection, you'll be able to:
- **Enable and Configure MCPs**: Set up the MCP system in Jan
- **Connect External Services**: Integrate with APIs, databases, and tools
- **Custom MCP Development**: Build your own MCP integrations
- **Troubleshoot Issues**: Debug and optimize MCP performance
- **Security Best Practices**: Keep your integrations secure
## Series Overview
This comprehensive tutorial series contains 8 hands-on videos that progress from basic setup to advanced custom development. Each video includes practical examples and real-world applications.
### Videos in This Series
1. **MCP Introduction & Setup** - Understanding MCP and initial configuration
2. **Enabling Your First MCP** - Step-by-step activation process
3. **Search Integration with Exa** - Connect web search capabilities
4. **Data Analysis with E2B** - Integrate code execution environments
5. **File System Access** - Local file and folder operations
6. **Custom API Integration** - Connect your own services
7. **Building Custom MCPs** - Develop your own integrations
8. **MCP Security & Best Practices** - Keep your integrations secure
## Who This Series Is For
- **Power Users**: Ready to extend Jan's capabilities
- **Developers**: Want to integrate Jan with existing tools
- **Business Users**: Need specialized AI workflows
- **System Administrators**: Managing Jan for teams
## Technical Requirements
<List title="System Requirements" variant="note" icon="laptop">
- Jan version 0.5.0 or later
- Active internet connection for external services
- API keys for third-party services (as needed)
- Administrative privileges for some integrations
</List>
## Popular MCP Use Cases
### Development Workflows
- **Code Analysis**: Analyze codebases and repositories
- **API Testing**: Test and document API endpoints
- **Database Queries**: Connect to databases for data analysis
- **CI/CD Integration**: Automate build and deployment tasks
### Business Applications
- **CRM Integration**: Access customer data and insights
- **Document Processing**: Analyze and process business documents
- **Spreadsheet Operations**: Read and manipulate Excel/Google Sheets
- **Email & Calendar**: Schedule meetings and send communications
### Research & Analysis
- **Web Scraping**: Gather data from websites
- **Academic Research**: Access scholarly databases
- **Market Analysis**: Connect to financial and market data
- **Social Media**: Analyze social media trends and data
## Time Investment
- **Total Runtime**: Approximately 2 hours
- **Hands-on Practice**: 4-6 hours additional
- **Recommended Schedule**: 2-3 videos per week
- **Completion Time**: 3-4 weeks with practice
## Learning Path
### Beginner Track (Videos 1-4)
Start here if you're new to MCPs. Learn the basics of setup and use popular pre-built integrations.
### Intermediate Track (Videos 5-6)
Ready to customize? Learn to configure advanced integrations and connect your own services.
### Advanced Track (Videos 7-8)
For developers and power users who want to build custom MCPs and implement enterprise-grade security.
## Support & Resources
- **Documentation**: Complete MCP reference guide
- **Community**: Discord channel for MCP users
- **Examples**: GitHub repository with sample integrations
- **Troubleshooting**: Common issues and solutions guide
Ready to supercharge your AI capabilities? MCPs will transform how you work with Jan!

57
website/src/content/docs/university/getting-started/getting-to-know-jan.mdx Normal file
View File

@ -0,0 +1,57 @@
---
title: Getting to Know Jan
description: Essential videos to understand Jan's core features and philosophy
video:
type: collection
collection: getting-to-know-jan
---
import { List } from 'starlight-videos/components';
# Getting to Know Jan
This series of videos introduces you to Jan's core concepts, features, and philosophy. Perfect for newcomers who want to understand what makes Jan special and how it fits into the AI landscape.
<List title="Prerequisites" variant="note" icon="open-book">
- A computer with 8GB+ RAM
- Basic familiarity with software installation
- Curiosity about AI and privacy
</List>
## What You'll Learn
By the end of this collection, you'll have a solid understanding of:
- **Jan's Mission**: Why Jan exists and what problems it solves
- **Privacy-First AI**: How Jan keeps your data secure and private
- **Local vs Cloud**: When to use local models vs cloud services
- **Open Source Benefits**: How Jan's open-source nature benefits you
- **Community & Support**: Where to get help and contribute back
## Series Overview
This tutorial series contains 6 essential videos that build upon each other. We recommend watching them in order for the best learning experience.
### Videos in This Series
1. **What is Jan?** - Introduction to Jan's mission and core features
2. **Privacy-First AI** - Understanding Jan's privacy approach
3. **Local AI Explained** - How local AI processing works
4. **Open Source Advantage** - Benefits of open-source AI tools
5. **Jan vs Alternatives** - How Jan compares to other AI tools
6. **Community & Getting Help** - Resources and support available
## Who This Series Is For
- **AI Newcomers**: People new to artificial intelligence
- **Privacy-Conscious Users**: Those concerned about data privacy
- **Open Source Enthusiasts**: Users interested in open-source software
- **Professionals**: Anyone considering AI for work applications
## Time Investment
- **Total Runtime**: Approximately 30 minutes
- **Recommended Schedule**: One video per day over a week
- **Completion Time**: 1 week at a relaxed pace
Ready to get started? The videos in this series will give you everything you need to understand Jan's unique approach to AI.

79
website/src/content/docs/university/getting-started/installation.mdx Normal file
View File

@ -0,0 +1,79 @@
---
title: Installing and Setting Up Jan
description: Get Jan running on your computer in minutes
video:
type: video
link: https://www.youtube.com/watch?v=oHg5SJYRHA0
duration: 300
---
import { List } from 'starlight-videos/components';
# Installing and Setting Up Jan
Now that you understand what Jan is and how it can help you, let's get it installed and running on your computer. This step-by-step video guide will walk you through the entire process.
## What You'll Learn
- How to download Jan for your operating system
- Installation process for Windows, macOS, and Linux
- Initial setup and configuration
- Downloading your first AI model
- Verifying everything is working correctly
## Prerequisites
<List title="System Requirements" variant="note" icon="laptop">
- A computer with at least 8GB of RAM (16GB recommended)
- 10GB of free disk space for Jan and one model
- A stable internet connection for initial download
- Administrator privileges on your computer
</List>
## Step-by-Step Process
### 1. Download Jan
- Visit the official Jan website
- Choose the correct version for your operating system
- Download and verify the installer
### 2. Installation
- Run the installer with administrator privileges
- Choose installation location and options
- Wait for the installation to complete
### 3. First Launch
- Start Jan for the first time
- Complete the initial setup wizard
- Configure basic preferences
### 4. Download Your First Model
- Browse the model library
- Understand different model sizes and capabilities
- Download a recommended beginner model
- Wait for the download to complete
### 5. Test Your Setup
- Start your first conversation
- Verify the model is responding
- Check system resources and performance
## Troubleshooting Common Issues
If you encounter problems during installation:
- **Permission errors**: Make sure you're running as administrator
- **Download failures**: Check your internet connection and firewall
- **Model loading issues**: Verify you have enough RAM and disk space
- **Performance problems**: Consider a smaller model for older hardware
## Next Steps
Once Jan is installed and your first model is downloaded, you'll be ready for **Your First AI Conversation**, where we'll learn the basics of communicating effectively with AI.
## System Requirements Reminder
- **Minimum**: 8GB RAM, 4GB free disk space
- **Recommended**: 16GB+ RAM, 20GB+ free disk space
- **Optimal**: 32GB+ RAM, SSD storage, dedicated GPU
Ready to install Jan? Follow along with the video and you'll be up and running in no time!

50
website/src/content/docs/university/getting-started/introduction.mdx Normal file
View File

@ -0,0 +1,50 @@
---
title: Introduction to AI and Jan
description: Your first step into the world of artificial intelligence
video:
type: video
link: https://www.youtube.com/watch?v=dQw4w9WgXcQ
duration: 180
---
# Introduction to AI and Jan
Welcome to your first lesson at Jan AI University! In this video, we'll explore what artificial intelligence is, how it can benefit you, and why Jan is the perfect tool to start your AI journey.
## What You'll Learn
- What is artificial intelligence and how does it work?
- The difference between traditional software and AI
- Why privacy matters in AI applications
- An overview of Jan's key features and benefits
- Real-world use cases for AI in your daily life
## Key Concepts Covered
### Artificial Intelligence Basics
- Large Language Models (LLMs) explained simply
- How AI "understands" and generates human language
- The training process and what makes AI "intelligent"
### Jan's Unique Approach
- Privacy-first design philosophy
- Local vs. cloud AI processing
- Open-source benefits and community
### Getting Started Mindset
- Setting realistic expectations for AI
- Understanding AI's strengths and limitations
- Building good prompting habits from day one
## After This Video
Once you've watched this introduction, you'll be ready to move on to **Installing and Setting Up Jan**, where we'll get Jan running on your computer and ready for your first AI conversation.
## Discussion Points
Think about these questions as you watch:
- What problems in your work or personal life could AI help solve?
- How important is data privacy to you when using AI tools?
- What are you most excited to try with Jan?
Ready to begin? Click play on the video above and let's start your AI journey together!

152
website/src/content/docs/university/getting-started/privacy-first-ai.mdx Normal file
View File

@ -0,0 +1,152 @@
---
title: Privacy-First AI
description: Understanding Jan's privacy approach and why it matters
video:
type: collection-video
link: https://www.youtube.com/watch?v=oHg5SJYRHA0
duration: 420
collection: getting-to-know-jan
order: 2
difficulty: Beginner
---
import { List, Quiz, QuizOption } from 'starlight-videos/components';
# Privacy-First AI
In this video, we dive deep into Jan's privacy-first philosophy and explore why keeping your AI interactions private matters more than ever.
<List title="Prerequisites" variant="note" icon="open-book">
- Watched "What is Jan?"
- Basic understanding of internet privacy concepts
- Awareness of data collection practices
</List>
## What You'll Learn
- Why privacy matters in AI applications
- How traditional AI services handle your data
- Jan's approach to keeping your conversations private
- Technical aspects of local data processing
- When and how to use cloud services safely with Jan
## Key Privacy Concepts
### The Privacy Problem with Cloud AI
- **Data Collection**: What happens to your conversations
- **Training Data**: How your inputs might be used
- **Government Access**: Potential surveillance concerns
- **Data Breaches**: Risks of centralized data storage
### Jan's Privacy Solutions
- **Local Processing**: Your data never leaves your device
- **No Logging**: Jan doesn't record your conversations
- **Open Source**: Complete transparency in data handling
- **User Control**: You decide what data to share and when
## Technical Deep Dive
### How Local Processing Works
- Model files stored on your device
- Computation happens on your hardware
- No network requests for basic operations
- Complete offline functionality
### Data Storage Locations
- Where Jan stores your conversations
- How to find and manage your data
- Backup and security considerations
- Deleting data permanently
### Hybrid Approach Benefits
- Use local models for sensitive content
- Cloud models for specialized tasks
- User-controlled data sharing
- Best of both worlds flexibility
## Real-World Privacy Scenarios
### Scenario 1: Medical Information
- Asking health-related questions
- Why local processing matters
- Regulatory compliance considerations
### Scenario 2: Business Confidential Data
- Company information and strategies
- Legal and competitive implications
- Corporate privacy policies
### Scenario 3: Personal Creative Work
- Writing and creative projects
- Intellectual property protection
- Personal expression privacy
## Making Privacy Choices
### When to Use Local Models
- Sensitive personal information
- Confidential business data
- Creative and original work
- Learning and experimentation
### When Cloud Models Might Be Appropriate
- General knowledge questions
- Public information research
- Non-sensitive creative tasks
- Performance-critical applications
## Privacy Best Practices
<List title="Privacy Checklist" variant="success" icon="approve-check">
- Review what data you're sharing
- Understand model capabilities and limitations
- Use local models for sensitive content
- Regularly review and clean your data
- Stay informed about privacy updates
</List>
## After This Video
You'll have a solid understanding of AI privacy concerns and Jan's solutions. Next up: **Local AI Explained** - where we'll explore the technical aspects of running AI on your own device.
## Reflection Questions
- What types of information do you consider private?
- How do current AI tools handle your data?
- What privacy features matter most to you?
- How would local AI change your usage patterns?
Ready to become a privacy-conscious AI user? Let's explore why privacy-first AI is the future!
## Privacy Knowledge Check
Test your understanding of AI privacy concepts:
<Quiz title="What happens to your conversations when using Jan locally?" variant="success">
<QuizOption>They are sent to Jan's servers for analysis</QuizOption>
<QuizOption>They are uploaded to the cloud for backup</QuizOption>
<QuizOption correct>They stay completely on your device</QuizOption>
<QuizOption>They are shared with model providers</QuizOption>
</Quiz>
<Quiz title="Which scenarios are best suited for local AI processing?" multiple variant="caution">
<QuizOption correct>Discussing confidential business strategies</QuizOption>
<QuizOption>Asking general knowledge questions</QuizOption>
<QuizOption correct>Working with sensitive medical information</QuizOption>
<QuizOption correct>Creating personal creative work</QuizOption>
<QuizOption>Looking up public information</QuizOption>
</Quiz>
<Quiz title="What is a key advantage of Jan's hybrid approach?" variant="note">
<QuizOption>It's always faster than other solutions</QuizOption>
<QuizOption correct>You can choose local for privacy and cloud for performance when needed</QuizOption>
<QuizOption>It requires no internet connection ever</QuizOption>
<QuizOption>It's completely free to use</QuizOption>
</Quiz>
<Quiz title="When using cloud services through Jan, whose privacy policies apply?" variant="caution">
<QuizOption>Only Jan's privacy policy</QuizOption>
<QuizOption>No privacy policies apply</QuizOption>
<QuizOption correct>The third-party service's privacy policies</QuizOption>
<QuizOption>Your company's privacy policies</QuizOption>
</Quiz>

97
website/src/content/docs/university/getting-started/what-is-jan.mdx Normal file
View File

@ -0,0 +1,97 @@
---
title: What is Jan?
description: Introduction to Jan's mission and core features
video:
type: collection-video
link: https://www.youtube.com/watch?v=dQw4w9WgXcQ
duration: 300
collection: getting-to-know-jan
order: 1
difficulty: Beginner
---
import { List, Quiz, QuizOption } from 'starlight-videos/components';
# What is Jan?
Welcome to your first video in the "Getting to Know Jan" series! This foundational video introduces you to Jan's core mission, key features, and what makes it different from other AI tools.
<List title="Prerequisites" variant="note" icon="open-book">
- No technical background required
- Basic computer literacy
- Interest in AI and privacy
</List>
## What You'll Learn
- The story behind Jan and why it was created
- Jan's core mission and values
- Key features that set Jan apart
- The difference between Jan and cloud-based AI services
- Real-world use cases and applications
## Key Topics Covered
### Jan's Origin Story
- Why the founders created Jan
- The problem Jan solves in the AI landscape
- Vision for the future of AI tools
### Core Features Overview
- **100% Offline Operation**: How Jan works without internet
- **Privacy-First Design**: Your data never leaves your device
- **Model Flexibility**: Use local and cloud models
- **Open Source**: Complete transparency and community-driven development
### Use Cases Preview
- Personal AI assistant for daily tasks
- Professional writing and research tool
- Educational companion for learning
- Development assistant for coding projects
## After This Video
You'll understand Jan's fundamental value proposition and be ready to explore how its privacy-first approach works in the next video: **Privacy-First AI**.
## Discussion Questions
As you watch, think about:
- What current AI tools do you use and what limitations do they have?
- How important is data privacy in your AI usage?
- What would you want to use Jan for in your daily life?
## Key Takeaways
By the end of this video, you should be able to:
- Explain what Jan is in your own words
- Identify Jan's main differentiators
- Understand why someone would choose Jan over alternatives
- Recognize potential use cases for your own needs
Ready to discover what makes Jan special? Let's dive in!
## Knowledge Check
Test your understanding of Jan's core concepts:
<Quiz title="What is Jan's primary differentiator from other AI tools?" variant="tip">
<QuizOption>It's faster than other AI tools</QuizOption>
<QuizOption correct>It runs completely offline and keeps your data private</QuizOption>
<QuizOption>It has more AI models available</QuizOption>
<QuizOption>It's easier to install</QuizOption>
</Quiz>
<Quiz title="Which of the following are key features of Jan?" multiple variant="note">
<QuizOption correct>100% offline operation</QuizOption>
<QuizOption>Cloud-only processing</QuizOption>
<QuizOption correct>Privacy-first design</QuizOption>
<QuizOption correct>Open source code</QuizOption>
<QuizOption>Subscription-based pricing</QuizOption>
</Quiz>
<Quiz title="What does Jan allow you to use?" variant="success">
<QuizOption>Only local AI models</QuizOption>
<QuizOption>Only cloud AI models</QuizOption>
<QuizOption correct>Both local and cloud AI models</QuizOption>
<QuizOption>Only models created by Jan</QuizOption>
</Quiz>

68
website/src/content/docs/university/index.mdx Normal file
View File

@ -0,0 +1,68 @@
---
title: Welcome to Jan AI University
description: Learn AI fundamentals and master Jan with our comprehensive video courses
---
import { Card, CardGrid } from '@astrojs/starlight/components';
Jan AI University is your comprehensive learning hub for mastering artificial intelligence concepts and getting the most out of Jan. Whether you're a beginner exploring AI for the first time or an advanced user looking to optimize your workflows, our video tutorial series will guide you through every step.
## What You'll Learn
<CardGrid>
<Card title="🚀 Getting Started" icon="rocket">
Master the basics of Jan installation, setup, and your first AI conversations. Perfect for newcomers to AI and Jan.
</Card>
<Card title="🧠 AI Fundamentals" icon="star">
Understand how large language models work, model parameters, and how to choose the right model for your needs.
</Card>
<Card title="⚙️ Advanced Techniques" icon="setting">
Dive deep into custom prompting, model fine-tuning, and advanced Jan configurations for power users.
</Card>
<Card title="🔧 Integration & Development" icon="puzzle">
Learn to integrate Jan with other tools, build applications using Jan's API, and extend Jan's capabilities.
</Card>
</CardGrid>
## Learning Paths
### 🌟 Beginner Path
Start here if you're new to AI or Jan. These tutorials build upon each other to give you a solid foundation.
1. **Introduction to AI and Jan** - Understand what AI can do for you
2. **Installing and Setting Up Jan** - Get Jan running on your system
3. **Your First AI Conversation** - Learn the basics of prompting
4. **Choosing the Right Model** - Understand different model types and capabilities
### 🚀 Intermediate Path
Ready to get more advanced? These tutorials will help you become proficient with Jan.
1. **Advanced Prompting Techniques** - Craft better prompts for better results
2. **Model Parameters Deep Dive** - Fine-tune models for your specific needs
3. **Local vs Cloud Models** - When to use each and how to switch
4. **Privacy and Security Best Practices** - Keep your data safe
### ⚡ Advanced Path
For power users and developers who want to push the boundaries.
1. **Jan API Integration** - Build applications using Jan's local server
2. **Custom Model Integration** - Add your own models to Jan
3. **Performance Optimization** - Get the most out of your hardware
4. **Enterprise Deployment** - Scale Jan for teams and organizations
## Featured Tutorial Series Preview
Coming soon: Our flagship tutorial series **"From Zero to AI Hero"** - a comprehensive 10-part video series that takes you from AI beginner to Jan expert in just 30 days.
## Learning Format
- **Video-first learning**: Each lesson is presented as an engaging video tutorial
- **Hands-on exercises**: Practice what you learn with real Jan examples
- **Downloadable resources**: Code samples, configuration files, and cheat sheets
- **Community support**: Join discussions with fellow learners in our Discord
## Getting Started
Ready to begin your AI journey? Start with our **Getting Started** section, where you'll find beginner-friendly videos that introduce you to the world of AI and Jan.
Have questions? Join our [Discord community](https://discord.gg/qSwXFx6Krr) where instructors and fellow students are always happy to help!

7
website/src/pages/example.mdx Normal file
View File

@ -0,0 +1,7 @@
---
title: Example Page
description: This is an example page.
---
# Hey