Contexts

Build A Living Knowledge Base For Your AI Workspace

Contexts are Springbase's knowledge bases: reusable memory layers that make AI responses grounded, specific, and aware of your work.

Instead of asking AI to answer from generic knowledge, attach a Context full of your docs, notes, meetings, webpages, or connected app data. Springbase can then respond using the information that actually matters to you.

Think of a Context as a living project brain:

• Upload documents and notes.
• Connect live sources that stay fresh over time.
• Share private Contexts with trusted collaborators.
• Use them in Chat with @mentions.
• Reuse the same knowledge across chats, workflows, and outputs.

What You Can Use Contexts For

Contexts are useful whenever you want AI to work from a specific body of knowledge instead of starting from scratch.

How Contexts Work

At a high level, a Context turns your source material into searchable knowledge Springbase can use during Chat.

The basic flow is:

1. Create a Context.
2. Add knowledge by uploading documents, adding notes, or connecting live sources.
3. Use it in Chat by starting from the Context or mentioning it with @.
4. Keep it fresh by adding new material, inviting collaborators, or using live sources.

Springbase uses Contexts as the memory layer behind grounded AI answers. Uploaded docs, PDFs, URLs, notes, and connected sources become searchable knowledge that can be retrieved when relevant.

1. Create A Context

A Context is the container for a knowledge base. In the UI, users see this as a Context; internally, Springbase may also refer to it as a project.

When To Create A New Context

Create a new Context when the knowledge should stay grouped around a specific goal, customer, project, team, or topic.

Good Context boundaries include:

• One company
• One client
• One investor relations workspace
• One sales account
• One research topic
• One support runbook
• One product area
• One recurring workflow

Avoid creating one massive "everything" Context unless the material truly belongs together. Smaller, purpose-built Contexts usually make answers easier to trust.

Example Contexts

2. Add Knowledge To A Context

Once you create a Context, add the source material Springbase should use.

Add Documents

Upload documents into a Context. Uploaded content becomes part of the searchable knowledge base Springbase can use during Chat.

Good documents to upload include:

• PDFs
• Strategy docs
• Meeting notes
• Pitch decks
• Product specs
• Research papers
• Sales notes
• Support articles
• Internal policies
• Customer feedback
• Competitive research

Add Text Or Notes

For lightweight information, add text directly into a Context.

Use this for:

• Quick notes
• Decisions
• Summaries
• Copy snippets
• Standing instructions
• Context that does not live in a file yet

Reprocess Failed Documents

If a document fails to process, retry or reprocess it.

This is useful when:

• A file upload was interrupted.
• A document did not parse correctly.
• A source needs to be refreshed.
• A collaborator uploaded something that needs retrying.

3. Use A Context In Chat

Use a Context directly in Chat so Springbase can answer from that knowledge base.

Springbase supports two main user-facing ways to use Contexts in Chat:

1. Use in Chat creates a new chat and attaches the selected Context.
2. @mention a Context references the Context inside any chat.

Example Prompts

Company Knowledge

Using @company-knowledge, summarize the latest product strategy and list the biggest open questions.

Investor Updates

Draft this month's investor update using @investor-relations.

Sales

Using @acme-enterprise, summarize the latest objections and draft a follow-up email.

Support

Answer this customer using @support-runbook, and include the escalation path if needed.

Research

Using @policy-research, compare the findings across these papers and extract claims about regulatory risk.

4. Choose Context Visibility

Contexts can have different visibility settings.

Springbase also supports publishing metadata such as tagline, cover image, category, tags, and source visibility. Source visibility controls whether source documents are visible publicly.

Use Private When

• The Context contains sensitive information.
• Only you should access it.
• You want to invite specific collaborators manually.

Examples:

• Investor materials
• Hiring plans
• Customer notes
• Internal strategy
• Financial model notes

Use Unlisted When

• You want to share by link.
• The Context should not be broadly discoverable.
• You want controlled distribution without full public discovery.

Examples:

• A client workspace
• A partner-facing knowledge base
• A lightweight external briefing hub

Use Public When

• You want others to discover and use the Context.
• The Context is safe to share.
• You are creating community knowledge.

Examples:

• Public research collection
• Public resource guide
• Open documentation set
• Shared industry knowledge base

5. Share Contexts With Collaborators

Shared Contexts let you keep a Context private while inviting trusted contributors to help maintain it. This is designed for collaboration without making the Context public or broadly discoverable.

For example:

A founder creates an Investor Updates Context. The Context stays private. The founder invites the CFO and assistant by email. They can upload decks and notes, but nobody else can discover or access the Context.

Why Shared Contexts Matter

Shared Contexts help when one person should control access, but multiple people need to keep the knowledge base updated.

Benefits include:

• The owner does not become the bottleneck.
• Collaborators can add or remove data.
• Sensitive information stays private.
• Access is email-bound.
• The owner can revoke access after the engagement ends.

What Editors Can Do

Editors can help maintain a shared Context.

Editors can:

• Upload documents
• Add text
• Delete documents
• Retry or reprocess failed documents
• Add and manage live data
• Use the shared Context in Chat retrieval

Document rows can also show who added a source when profile data is available.

What Non-Editors Cannot Do

Public or unlisted viewers may be able to read or use Contexts depending on visibility rules, but they are not editors.

Non-editors should not see controls such as:

• Upload document
• Delete document
• Add live source
• Reprocess document
• Share settings
• Delete Context

6. Shared Context Use Cases

Founder Knowledge Base

A founder creates a Context for company knowledge:

• Investor docs
• Product strategy
• Hiring plans
• Customer notes
• Competitor research

The founder invites:

• Chief of staff
• Operations lead
• Assistant

Why it helps: the founder keeps access control, while trusted teammates keep the Context current.

Sales Team Account Context

A sales lead creates a Context for a strategic account:

• Call notes
• CRM exports
• Proposals
• Objection handling
• Competitive intel
• Mutual action plans

The sales lead invites:

• Account executive
• Sales engineer
• Customer success manager

Example prompts:

Summarize the latest objections from @acme-enterprise.

Draft a follow-up email using the pricing notes and technical requirements.

What did they care about most in the last meeting?

Why it helps: account knowledge stays in one place, and the AI can answer from the combined account record.

Investor Relations Context

A startup creates a Context for investor communications:

• Pitch deck
• Financial model notes
• Monthly updates
• Board meeting notes
• Investor Q&A

The CEO invites:

• Finance lead
• External advisor

Example prompts:

Draft this month's investor update using @investor-relations.

Summarize all open questions investors asked last quarter.

Create a board-prep checklist from the latest notes.

Why it helps: external collaborators do not need to belong to an internal team, sensitive information remains private, and access can be revoked later.

Client Project Workspace

An agency creates a Context per client:

• Discovery notes
• Brand docs
• Meeting transcripts
• Strategy docs
• Content calendars
• Design feedback

The agency invites client stakeholders by email.

Example prompts:

Generate next week's content ideas from @client-brand.

Summarize unresolved feedback.

Write a launch announcement consistent with the client's tone.

Why it helps: clients can contribute source material directly, while the agency controls access and removal.

Research Repository

A researcher or analyst creates a Context around a topic:

• PDFs
• Web captures
• Notes
• Data exports
• Summaries

They invite collaborators from other institutions or companies.

Example prompts:

Compare the findings across these papers.

Extract all claims about regulatory risk.

Build a briefing memo from @policy-research.

Why it helps: invitees do not need to be in the same organization, and everyone can add evidence.

Support Runbook Context

A support manager creates a Context for:

• Troubleshooting docs
• Known issues
• Product FAQs
• Escalation rules
• Internal notes

Support leads and product managers are invited by email.

Example prompts:

Answer this customer using @support-runbook.

Find the escalation path for this issue.

What changed in the latest support process?

Why it helps: runbooks stay current, product and support can maintain the source material together, and support agents get grounded answers.

7. Use Live Contexts

Live Contexts let your Context stay up to date by connecting auto-updating sources from the web and connected apps.

Springbase's Live Data layer includes:

• Auto-updating sources from web and connected apps
• Scheduled ingestion
• Crawl and sync logs
• Per-item tracking
• Source health management
• Service ingestion for tools such as Slack, GitHub, and Notion

What Live Sources Are For

Use live sources when the knowledge changes often and you do not want to manually upload new files every time.

Good live source candidates include:

• Public webpages
• Documentation sites
• Internal knowledge sources
• Slack information
• GitHub activity or repositories
• Notion pages or workspaces

Live Context Examples

Product Documentation Context

Connect product docs so your AI assistant can answer from the latest documentation.

Example prompts:

What changed in the latest docs?

Summarize the setup flow from the current documentation.

Engineering Context

Connect GitHub-related knowledge for engineering workflows.

Example prompts:

Summarize recent implementation notes.

What files or areas are relevant to this feature?

Team Knowledge Context

Connect Slack or Notion sources so team knowledge can flow into a shared Context.

Example prompts:

Summarize the latest discussion about onboarding.

What decisions were made recently about pricing?

Managing Live Sources

Springbase supports live source management including:

• Creating live sources
• Updating live sources
• Triggering crawls or syncs
• Pausing live sources
• Viewing logs
• Viewing tracked pages or items
• Validating live sources

This makes Live Contexts useful not just for ingestion, but also for monitoring whether sources are healthy and current.

8. Community Contexts

Springbase includes a community layer for published Contexts.

Community Contexts can be:

• Published
• Discovered
• Equipped
• Favorited
• Shared
• Tracked with analytics

What Equip Means

Equipping a Context lets a user make a community Context available for use.

Springbase tracks community activity such as equip count, weekly active users, total RAG queries, average rating, and rating count.

Use public or community Contexts when you want knowledge to be reusable by a broader audience.

Examples:

• Public research collections
• Open-source project docs
• Industry explainers
• Public company resources
• Community playbooks

9. Best Practices For Better Contexts

Give Each Context A Clear Purpose

A good Context should answer the question:

What should this knowledge base help me do?

Examples:

• Help us answer investor questions.
• Help support agents resolve customer issues.
• Help sales understand this account.
• Help writers stay consistent with this client's brand.

Keep Related Knowledge Together

Put documents together when they support the same workflow.

For example, an Investor Relations Context might include:

• Pitch deck
• Monthly updates
• Board notes
• Investor questions
• Financial model notes

Do not mix unrelated knowledge unless users will naturally ask about those topics together.

Use Shared Contexts For Team-Maintained Knowledge

If one person owns the Context but several people have the latest information, invite collaborators.

This works especially well for:

• Founder knowledge bases
• Sales account workspaces
• Client projects
• Research repositories
• Support runbooks

Use Live Sources For Fast-Moving Knowledge

If information changes frequently, use live sources instead of repeatedly uploading static files.

Good candidates:

• Docs sites
• Notion workspaces
• Slack knowledge
• GitHub sources
• Webpages that change over time

Review Access Regularly

For sensitive Contexts, periodically check:

• Who owns the Context
• Who has editor access
• Whether the Context is private, unlisted, or public
• Whether source visibility is open or closed
• Whether former collaborators should be removed

This is especially important for investor, client, hiring, financial, or customer data.

10. Example: Investor Relations Context

Goal

Create a private Context that helps draft updates, answer investor questions, and prepare for board meetings.

Step 1: Create The Context

Name it:

Investor Relations

Set visibility to:

Private

Private visibility keeps access limited to the owner unless collaborators are invited.

Step 2: Upload Source Material

Add:

• Pitch deck
• Financial model notes
• Monthly investor updates
• Board meeting notes
• Investor Q&A
• Fundraising notes

Step 3: Invite Collaborators

Invite trusted contributors by email, such as:

• Finance lead
• External advisor
• Assistant

Shared Contexts allow invited collaborators to help maintain private Context data.

Step 4: Use It In Chat

Try prompts like:

Draft this month's investor update using @investor-relations.

Summarize all open questions investors asked last quarter.

Create a board-prep checklist from the latest notes.

Step 5: Keep It Updated

Each month:

• Upload the latest update.
• Add new investor questions.
• Remove outdated documents if needed.
• Reprocess failed uploads.
• Review editor access.

11. Example: Sales Account Context

Goal

Create a shared account workspace for a strategic customer.

Step 1: Create The Context

Name it after the account:

Acme Enterprise

Step 2: Add Account Knowledge

Upload or add:

• Call notes
• CRM exports
• Proposals
• Objection handling
• Competitive intel
• Mutual action plans

Step 3: Invite The Account Team

Invite:

• Account executive
• Sales engineer
• Customer success manager

Step 4: Use It In Chat

Try:

Summarize the latest objections from @acme-enterprise.

Draft a follow-up email using the pricing notes and technical requirements.

What did they care about most in the last meeting?

12. Example: Support Runbook Context

Goal

Create a living support runbook that helps support agents answer customers with grounded information.

Step 1: Create The Context

Name it:

Support Runbook

Step 2: Add Support Knowledge

Add:

• Troubleshooting docs
• Known issues
• Product FAQs
• Escalation rules
• Internal notes

Step 3: Invite Maintainers

Invite:

• Support leads
• Product managers

This lets both support and product maintain the source material.

Step 4: Ask Support Questions

Try:

Answer this customer using @support-runbook.

Find the escalation path for this issue.

What changed in the latest support process?

13. Troubleshooting

The AI Answer Seems Too Generic

Try:

• Make sure the relevant Context is attached or @mentioned.
• Add more specific source material.
• Ask the question more directly.
• Split unrelated knowledge into separate Contexts.

Contexts make responses grounded and workspace-aware when the relevant knowledge is available.

A Collaborator Cannot Edit The Context

Check whether they are an editor.

Editors can upload documents, add text, delete documents, retry failed documents, and manage live data. Non-editors should not see edit controls.

A Context Should Not Be Public

Use private visibility for owner-only access, or shared private access when specific collaborators need to help maintain it.

A Source Keeps Changing

Use a Live Context source when information updates frequently. Live sources support scheduled ingestion, logs, per-item tracking, and source health management.

14. Quick Start Checklist

Use this checklist to create your first high-quality Context.

• Pick one clear purpose for the Context.
• Give it a specific name.
• Choose the right visibility: private, unlisted, or public.
• Upload the most important documents.
• Add notes or text for missing context.
• Invite collaborators if others should maintain it.
• Add live sources if the knowledge changes often.
• Use the Context in Chat with Use in Chat or @mention.
• Review answers and add missing source material.
• Keep access and source visibility up to date.

Summary

Contexts are the foundation of grounded AI work in Springbase. They turn scattered documents, notes, meetings, web sources, and connected app data into a reusable memory layer.

Use:

• Private Contexts for sensitive personal or company knowledge.
• Shared Contexts when trusted collaborators need to help maintain a private knowledge base.
• Live Contexts when source material changes frequently.
• Community Contexts when useful knowledge should be discoverable and reusable by others.

The result: less copy-pasting, fewer repeated explanations, and AI that actually knows what you are talking about.