text:
Sylvester's sequence
Sylvester's sequence, OEIS A000058, is an integer sequence defined as follows:
Each member is the product of all previous members plus one.  The first member of the sequence is 2.
Task
Create a program to calculate the nth term of Sylvester's Sequence.  Standard input, output and loopholes apply.
Standard sequence rules apply.
This is code-golf, so the goal is to minimize the size of your source code as measured in bytes.
Test Cases
You may use either zero or one indexing. (Here I use zero indexing)
>>0
2
>>1
3
>>2
7
>>3
43
>>4
1807

What inputs are expected to be handled? The output grows quite rapidly.

@Geobits you are expected to handle as much as your language can

TypeScript’s type system can handle unary numbers up to 999, but could also take the input as a list of base-10 digits and do math in those, but for many more bytes. Would the first be acceptable, or must I choose the second since it’s possible?

Brain-Flak, 76 68 58 52 46 bytes
<>(()())<>{({}[()])<>({({}[()])({})}{}())<>}<>

Try it online!
Uses this relationship instead:
$$a(n) = 1+\sum^{a(n-1)-1}_{i=0} 2i$$
which is derived from this relationship modified from that provided in the sequence:
$$a(n+1) = a(n)(a(n) - 1) + 1.$$
Explanation
For a documentation of what each command does, please visit the GitHub page.
There are two stacks in Brain-Flak, which I shall name as Stack 1 and Stack 2 respectively.
The input is stored in Stack 1.
<>(()())<>             Store 2 in Stack 2.

{                      while(Stack_1 != 0){
  ({}[()])                 Stack_1 <- Stack_1 - 1;
  <>                       Switch stack.
  ({({}[()])({})}{}())     Generate the next number in Stack 2.
  <>                       Switch back to Stack 1.
}

<>                     Switch to Stack 2, implicitly print.

For the generation algorithm:
({({}[()])({})}{}())      Top <- (Top + Top + (Top-1) + (Top-1) + ... + 0) + 1

(                  )      Push the sum of the numbers evaluated in the process:

 {            }               while(Top != 0){
  ({}[()])                        Pop Top, push Top-1    (added to sum)
          ({})                    Pop again, push again  (added to sum)
                              }

               {}             Top of stack is now zero, pop it.
                 ()           Evaluates to 1 (added to sum).

Alternative 46-byte version
This uses only one stack.
({}<(()())>){({}<({({}[()])({})}{}())>[()])}{}

Try it online!

Only 10 more bytes to show that java develepors should go to brain flack

@RohanJhunjhunwala I'm afraid that's impossible...

@LeakyNun it still is interesting to think of. Brain Flak has some power, and is suprisingly terse

The one stack version is also stack clean.  Which tends to be a important point for code modularity in brain-flak.

Wow. This is an extremely impressive answer.

@DJMcMayhem Thank you, I am flattered.

Jelly, 5 bytes
Ḷß€P‘

This uses 0-based indexing and the definition from the challenge spec.
Try it online! or verify all test cases.
How it works
Ḷß€P‘  Main link. Argument: n

Ḷ      Unlength; yield [0, ..., n - 1].
 ß€    Recursively apply the main link to each integer in that range.
   P   Take the product. This yields 1 for an empty range.
    ‘  Increment.

Ah, I forgot that the empty product is 1.

Hexagony, 27 bytes
1{?)=}&~".>")!@(</=+={"/>}*

Unfolded:
    1 { ? )
   = } & ~ "
  . > " ) ! @
 ( < / = + = {
  " / > } * .
   . . . . .
    . . . .

Try it online!
Explanation
Let's consider the sequence b(a) = a(n) - 1 and do a little rearranging:
b(a) = a(n) - 1
     = a(n-1)*(a(n-1)-1) + 1 - 1
     = (b(n-1) + 1)*(b(n-1) + 1 - 1)
     = (b(n-1) + 1)*b(n-1)
     = b(n-1)^2 + b(n-1)

This sequence is very similar but we can defer the increment to the very end, which happens to save a byte in this program.
So here is the annotated source code:

Created with Timwi's HexagonyColorer.
And here is a memory diagram (the red triangle shows the memory pointer's initial position and orientation):

Created with Timwi's EsotericIDE.
The code begins on the grey path which wraps the left corner, so the initial linear bit is the following:
1{?)(
1      Set edge b(1) to 1.
 {     Move MP to edge N.
  ?    Read input into edge N.
   )(  Increment, decrement (no-op).

Then the code hits the < which is a branch and indicates the start (and end) of the main loop. As long as the N edge has a positive value, the green path will be executed. That path wraps around the grid a few times, but it's actually entirely linear:
""~&}=.*}=+={....(

The . are no-ops, so the actual code is:
""~&}=*}=+={(
""             Move the MP to edge "copy".
  ~            Negate. This is to ensure that the value is negative so that &...
   &           ...copies the left-hand neighbour, i.e. b(i).
    }=         Move the MP to edge b(i)^2 and turn it around.
      *        Multiply the two copies of b(i) to compute b(i)^2.
       }=      Move the MP back to edge b(i) and turn it around.
         +     Add the values in edges "copy" and b(i)^2 to compute
               b(i) + b(i)^2 = b(i+1).
          ={   Turn the memory pointer around and move to edge N.
            (  Decrement.

Once this decrementing reduces N to 0, the red path is executed:
")!@
"     Move MP back to edge b(i) (which now holds b(N)).
 )    Increment to get a(N).
  !   Print as integer.
   @  Terminate the program.

Can you run your bruteforcer on this?

@CalculatorFeline The brute forcer can do at most 7-byte programs (and even that only with a bunch of assumptions) in a reasonable amount of time. I don't see this being remotely possible in 7 bytes.

So? What's wrong with trying?

@CalculatorFeline Laziness. The brute forcer always requires a bit of manual tweaking that I can't be bothered to do for the practically 0 chance that it will find something. Some version of the script is on GitHub though so anyone else is free to give it a go.

And how do I do that?

@CalculatorFeline The outer loops specify some characters that need to appear in the code (for this program those would probably be ?, ! and @) and iterate over all their possible positions. The inner loop then iterates over all possible programs with those characters in place using the alphabet defined on line 18. Inside the loop you can invoke the interpreter with some dummy streams and test for various input/output pairs.

Getting an invalid byte sequence error on line 31. Help :(

Let us continue this discussion in chat.

Perl 6, 24 bytes
{(2,{1+[*] @_}...*)[$_]}

{(2,{1+.²-$_}...*)[$_]}

Explanation
# bare block with implicit parameter ｢$_｣
{
  (
    # You can replace 2 with 1 here
    # so that it uses 1 based indexing
    # rather than 0 based
    2,

    # bare block with implicit parameter ｢@_｣
    {
      1 +

      # reduce the input of this inner block with ｢&infix:<*>｣
      # ( the input is all of them generated when using a slurpy @ var )
      [*] @_

      # that is the same as:
      # ｢@_.reduce: &infix:<*>｣
    }

    # keep calling that to generate more values until:
    ...

    # forever
    *

  # get the value as indexed by the input
  )[ $_ ]
}

Usage:
my &code = {(2,{1+[*] @_}...*)[$_]}

say code 0; # 2
say code 1; # 3
say code 2; # 7
say code 3; # 43
say code 4; # 1807

# you can even give it a range
say code 4..7;
# (1807 3263443 10650056950807 113423713055421844361000443)

say code 8;
# 12864938683278671740537145998360961546653259485195807
say code 9;
# 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443
say code 10;
# 27392450308603031423410234291674686281194364367580914627947367941608692026226993634332118404582438634929548737283992369758487974306317730580753883429460344956410077034761330476016739454649828385541500213920807

my $start = now;
# how many digits are there in the 20th value
say chars code 20;
# 213441

my $finish = now;
# how long did it take to generate the values up to 20
say $finish - $start, ' seconds';
# 49.7069076 seconds

An array slice with $_? What witchcraft is this?

J, 18 14 12 bytes
This version thanks to randomra. I'll try to write a detailed explanation later.
0&(]*:-<:)2:

J, 14 bytes
This version thanks to miles. Used the power adverb ^: instead of an agenda as below. More explanation to come.
2(]*:-<:)^:[~]

J, 18 bytes
2:`(1+*/@$:@i.)@.*

0-indexed.
Examples
   e =: 2:`(1+*/@$:@i.)@.*
   e 1
3
   e 2
7
   e 3
43
   e 4
1807
   x: e i. 10
2 3 7 43 1807 3263443 10650056950807 113423713055421862298779648 12864938683278674737956996400574416174101565840293888 1655066473245199944217466828172807675196959605278049661438916426914992848    91480678309535880456026315554816
   |: ,: x: e i. 10
                                                                                2
                                                                                3
                                                                                7
                                                                                43
                                                                                1807
                                                                                3263443
                                                                                10650056950807
                                                                              113423713055421862298779648
                                                    12864938683278674737956996400574416174101565840293888
165506647324519994421746682817280767519695960527804966143891642691499284891480678309535880456026315554816

Explanation
This is an agenda that looks like this:
           ┌─ 2:
           │    ┌─ 1
       ┌───┤    ├─ +
       │   └────┤           ┌─ / ─── *
── @. ─┤        │     ┌─ @ ─┴─ $:
       │        └─ @ ─┴─ i.
       └─ *

(Generated using (9!:7)'┌┬┐├┼┤└┴┘│─' then 5!:4<'e')
Decomposing:
       ┌─ ...
       │
── @. ─┤
       │
       └─ *

Using the top branch as a the gerund G, and the bottom as the selector F, this is:
e n     <=>     ((F n) { G) n

This uses the constant function 2: when 0 = * n, that is, when the sign is zero (thus n is zero). Otherwise, we use this fork:
  ┌─ 1
  ├─ +
──┤           ┌─ / ─── *
  │     ┌─ @ ─┴─ $:
  └─ @ ─┴─ i.

Which is one plus the following atop series:
            ┌─ / ─── *
      ┌─ @ ─┴─ $:
── @ ─┴─ i.

Decomposing further, this is product (*/) over self-reference ($:) over range (i.).

You can also use the power adverb to get 2(]*:-<:)^:[~] for 14 bytes using the formula a(0) = 2 and a(n+1) = a(n)^2 - (a(n) - 1). To compute larger values, the 2 at the start will have to be marked as an extended integer.

Both solutions are very nice. I think I was unaware of the v`$:@.u recursive format. I always used a ^:v format which is often more complex. @miles I also never used the (]v) trick. It took me a good 5 minutes to understand it.

For completeness a 3rd kind of looping (14 bytes using miles's method): 2(]*:-<:)~&0~] (or 2:0&(]*:-<:)~]). And combining them 13 bytes ]0&(]*:-<:)2:.

12 bytes: 0&(]*:-<:)2:. (Sorry, I shouldn't golf in the comments.)

@randomra That is a really neat use of bond. I had to read the page to find out exactly what happened since normally one would think that middle verb was receiving three arguments.

This might be the most baffling thing I've ever seen.  Well done. :)

I just noticed that this could be a byte shorter with either 1&(+*:-])2: or 1&(+]*<:)2:

Haskell, 26 bytes
f n|n<1=2|m<-f$n-1=1+m*m-m

Usage example: f 4 -> 1807.

Java 7, 46 42 bytes
int f(int n){return--n<0?2:f(n)*~-f(n)+1;}

Uses 0-indexing with the usual formula. I swapped n*n-n for n*(n-1) though, since Java doesn't have a handy power operator, and the f() calls were getting long.

f(n)*~-f(n) should work.

How do I forget about that trick every single time? If that isn't on the tips page, it's damn sure about to be.

return--n<0 saves one more byte.

Oh thanks. I was looking for a way to get rid of that space, but didn't see it.

But java developers should go to brain-flak anyway.

@Leaky Nun If I can't simulate a simple die roll without rolling my own PRNG, I'm not a fan of it :P

I redid this answer in Groovy for 26 bytes: a={n->n--?a(n)*~-a(n)+1:2} +1 man, and +1 to Dennis for coming in with the shortcuts like always, haven't used that shortcut before, cool to learn new stuff like that.

Haskell, 25 bytes
(iterate(\m->m*m-m+1)2!!)

S.I.L.O.S, 60 bytes
readIO
p = 2
lblL
r = p
r + 1
p * r
i - 1
if i L
printInt r

Try it online!
Port of my answer in C.

Yay :D finally a SILOS golfer, the interesting thing is that it beats Scala :)

Oasis, 4 bytes
Probably my last language from the golfing family! Non-competing, since the language postdates the challenge.
Code:
²->2

Alternative solution thanks to Zwei:
<*>2

Expanded version:
a(n) = ²->
a(0) = 2

Explanation:
²    # Stack is empty, so calculate a(n - 1) ** 2.
 -   # Subtract, arity 2, so use a(n - 1).
  >  # Increment by 1.

Uses the CP-1252 encoding. Try it online!

Last golfing language? You're not going to make any more? D:

@ConorO'Brien Probably, I'm out of ideas now :(

Before looking at this challenge, I got b<*>2 using a(n-1)*(a(n-1)+1)-1

@Zwei Very neat! You can actually leave out the b since that will be automatically filled in (rather than the input) :).

Yup, I noticed that after posting. I'm surprised how well this language works for this, even though it is designed for sequences.

R,  44 42 41 bytes
2 bytes save thanks to JDL
1 byte save thanks to user5957401
f=function(n)ifelse(n,(a=f(n-1))^2-a+1,2)

It's not clear from the problem statement, but as long as n is guaranteed to not be negative then the condition can be reduced from n>0 to just n.

@JDL Nice ! Thanks !

f(n-1) is 6 bytes. I think you save a byte by assigning it to something. i.e. ifelse(n,(a=f(n-1))^2-a+1,2)

Brain-Flak, 158 154 bytes
Leaky Nun has me beat here
({}<(()())>){({}[()]<<>(())<>([]){{}<>({}<<>(({}<>))><>)<>({<({}[()])><>({})<>}{})<>{}([])}{}<>({}())([]){{}({}<>)<>([])}{}<>>)}{}([][()]){{}{}([][()])}{}

Try it Online!
Explanation
Put a two under the input a(0)
({}<(()())>)

While the input is greater than zero subtract one from the input and...
{
({}[()]

Silently...
<

Put one on the other stack to act as a catalyst for multiplication
     <>(())<>
While the stack is non-empty
 ([])
 {
  {}

Move the top of the list over and copy
  <>({}<<>(({}<>))><>)

Multiply the catalyst by the copy
  <>({<({}[()])><>({})<>}{})<>{}
  ([])
 }
 {}

Add one
 <>({}())

Move the sequence back to the proper stack
 ([])
 {
 {}
 ({}<>)<>
 ([])
 }
 {}
 <>
>)
}{}

Remove all but the bottom item (i.e. the last number created)
([][()])
{
{}
{}
([][()])
}
{}

C, 32 bytes
f(n){return--n?f(n)*~-f(n)+1:2;}

Uses 1-based indexing. Test it on Ideone.

Actually, 9 bytes
2@`rΣτu`n

Try it online!
Uses this relationship instead:

which is derived from this relationship modified from that provided in the sequence:
a(n+1) = a(n) * (a(n) - 1) + 1.

Python, 38 36 bytes
2 bytes thanks to Dennis.
f=lambda n:0**n*2or~-f(n-1)*f(n-1)+1

Ideone it!
Uses this relationship modified from that provided in the sequence instead:
a(n+1) = a(n) * (a(n) - 1) + 1
Explanation
0**n*2 returns 2 when n=0 and 0 otherwise, because 0**0 is defined to be 1 in Python.

K (oK), 12 bytes
{2|1+*/o'!x}

Try it online!
Blatantly stolen from Port of Adám's answer.
Prints up to the first 11 elements of the sequence, after which the numbers become too big to handle.
Thanks @ngn for 6 bytes!
How:
{2|1+*/o'!x} # Main function, argument x.
       o'!x  # recursively do (o) for each (') of [0..x-1] (!x)
   1+*/      # 1 + the product of the list
 2|          # then return the maximum between that product and 2.

R, 50 46 44 bytes
    n=scan();v=2;if(n)for(i in 1:n){v=v^2-v+1};v

Rather than tracking the whole sequence, we just keep track of the product, which follows the given quadratic update rule as long as n>1 n>0. (This sequence uses the "start at one zero" convention)
Using the start at zero convention saves a couple of bytes since we can use if(n) rather than if(n>1)

Jellyfish, 13 bytes
p
\Ai
&(*
><2

Try it online!
Explanation
Let's start from the bottom up:
(*
<

This is a hook, which defines a function f(x) = (x-1)*x.
&(*
><

This composes the previous hook with the increment function so it gives us a function g(x) = (x-1)*x+1.
\Ai
&(*
><

Finally, this generates a function h which is an iteration of the previous function g, as many times as given by the integer input.
\Ai
&(*
><2

And finally, we apply this iteration to the initial value 2. The p at the top just prints the result.
Alternative (also 13 bytes)
p
>
\Ai
(*
>1

This defers the increment until the very end.

Prolog, 49 bytes
a(0,2).
a(N,R):-N>0,M is N-1,a(M,T),R is T*T-T+1.

SILOS 201 bytes
readIO
def : lbl
set 128 2
set 129 3
j = i
if j z
print 2
GOTO e
:z
j - 1
if j Z
print 3
GOTO e
:Z
i - 1
:a
a = 127
b = 1
c = 1
:b
b * c
a + 1
c = get a
if c b
b + 1
set a b
i - 1
if i a
printInt b
:e

Feel free to try it online!

What the hell is going on

@TùxCräftîñg witchcraft

Jelly, 7 bytes
²_’
2Ç¡

Try it online!
Uses this relationship provided in the sequence instead: a(n+1) = a(n)^2 - a(n) + 1
Explanation
2Ç¡   Main chain, argument in input

2     Start with 2
  ¡   Repeat as many times as the input:
 Ç        the helper link.

²_’   Helper link, argument: z
²     z²
  ’   z - 1
 _    subtraction, yielding z² - (z-1) = z² - z + 1

Cheddar, 26 bytes
n g->n?g(n-=1)**2-g(n)+1:2

Try it online!
Pretty idiomatic.
Explanation
n g ->    // Input n, g is this function
  n ?     // if n is > 1
    g(n-=1)**2-g(n)+1   // Do equation specified in OEIS
  : 2     // if n == 0 return 2

Now 4 times (almost)

Why did you remove the TIO link?

@LeakyNun oh you must of been editing while I was

CJam, 10 bytes
2{_(*)}ri*

Uses 0-based indexing. Try it online!

05AB1E, 7 bytes
2sFD<*>

Explained
Uses zero-based indexing.
2         # push 2 (initialization for n=0)
 sF       # input nr of times do
   D<*    # x(x-1)
      >   # add 1

Try it online!

Mathematica, 19 bytes
Nest[#^2-#+1&,2,#]&

Or 21 bytes:
Array[#0,#,0,1+1##&]&

The Array solution is magical. Too bad, ##0 is not a thing. ;)

Red, 55 49 45 39 bytes
func[n][x: 2 loop n[x: x * x - x + 1]x]

Try it online!

-6 thanks to Galen Ivanov
-4 thanks to Pedro Maimere
-6 thanks to 9214

This is the first real thing I wrote in Red. You have been warned.

You can use if instead of either and explicitly return x for 49 bytes

@GalenIvanov Thanks!

n > 0 to n 45 bytes

@PedroMaimere Thanks, I'll have to remember that works!

What do you need if for? It will always evaluate its body if n is an integer, which is treated as truthy value.

@9214 loop 0 is none, so I have to treat an input of 0 specially.

@chunes "specially" how? I don't see any check for 0, and 0 is not the same as logical false in the language. func[n][x: 2 loop n[x: x * x - x + 1]x] is enough.

@9214 You're right. I see what's going on now. From the previous comment, it seemed like 0 is logical false in Red, but we don't need if if we unconditionally return x. Thanks!

C, 43, 34, 33 bytes
1-indexed:
F(n){return--n?n=F(n),n*n-n+1:2;}

Test main:
int main() {
  printf("%d\n", F(1));
  printf("%d\n", F(2));
  printf("%d\n", F(3));
  printf("%d\n", F(4));
  printf("%d\n", F(5));
}

Brachylog, 13 bytes
0,2|-:0&-y+*+

Try it online!
Uses this relationship instead:

which is derived from this relationship modified from that provided in the sequence:
a(n+1) = a(n) * (a(n) - 1) + 1.

Labyrinth, 18 bytes
Credits to Sp3000 who found the same solution independently.
?
#
)}"{!@
* (
(:{

Try it online!

Python 2, 87 73 64 60 51 bytes
14 23 25 bytes saved thanks to Leaky Nun
9 bytes saved thanks to  Specter Terrasbane
Here's my go at my own challenge.
f=lambda x:reduce(int.__mul__,[1]+map(f,range(x)))+1

instead of using o.mul, you can use int.__mul__

You can also do it recursively.

lambda x:reduce(lambda y,z:y+[reduce(int.__mul__,y)+1],[2])[-1] I don't know what you pre-initialized the array for.

Also range(x-1) is equivalent to range(0,x-1)

You should specify this as Python 2 due to the reduce, which would require importing functools in 3. Edit: Also it does not seem to work

Replace [f(y)for y in range(x)] with map(f,range(x)) to save another 8.

C, 46 bytes
s(n,p,r){for(p=r=2;n-->0;p*=r)r=p+1;return r;}

Ideone it!
Uses p as the temporary storage of the product.
Basically, I defined two sequences p(n) and r(n), where r(n)=p(n-1)+1 and p(n)=p(n-1)*r(n).
r(n) is the required sequence.

Any reason you're not using the same relation from your Python answer here? That should be a lot shorter...

@Dennis This is more interesting.

@Dennis And this answer can be ported

Haskell, 27 bytes
f 0=2
f n=f(n-1)^2-f(n-1)+1

Try it online!
Not the shortest Haskell answer but it uses a new method.

Flurry, 26 bytes
{}[(<><<>()>)({})]{{}}{}{}

Verification
$ echo -n "{}[(<><<>()>)({})]{{}}{}{}" | wc -c
26
$ ./flurry -nin -c "{}[(<><<>()>)({})]{{}}{}{}" 0
2
$ ./flurry -nin -c "{}[(<><<>()>)({})]{{}}{}{}" 1
3
$ ./flurry -nin -c "{}[(<><<>()>)({})]{{}}{}{}" 2
7
$ ./flurry -nin -c "{}[(<><<>()>)({})]{{}}{}{}" 3
43
$ ./flurry -nin -c "{}[(<><<>()>)({})]{{}}{}{}" 4
1807

How it works
We have a formula \$a(n+1) = a(n) (a(n) - 1) + 1\$, but pred is well-known to be expensive in SKI calculus, so I defined an auxiliary sequence:
$$
b(n) = a(n)-1 \\
a(n+1) - 1 = (a(n)-1+1)(a(n)-1) \\
b(n+1) = b(n)(b(n)+1), b(0) = 1
$$
Then we can use the nature of Church numerals to calculate the \$n\$-th term as
b = \n. n (\x. x ∘ succ x) 1
a = \n. succ (b n)
  = \n. succ (n (\x. x ∘ succ x) 1)

where succ is the successor function and ∘ is function composition (which acts as multiplication when given two Church numerals).
We can represent the \x. x ∘ succ x part directly in Flurry as {<({})[<><<>()>{}]>}, but we can do better. We can try converting to SKB:
\x. \f. x (succ x f)
\x. \f. K x f (succ x f)
\x. S (K x) (succ x)
\x. (S∘K) x (succ x)
S (S∘K) succ
succ succ  (because succ = S (S∘K))

So we can duplicate succ via the stack, making it [(<><<>()>){}] (-6 bytes). Using it in the full program, we get:
\n. succ (n (\x. x ∘ succ x) 1)
\n. succ (n (succ succ) 1)

<><<>()>[       succ (
 {}[              n (
    (<><<>()>)       succ [push succ]
    {}               succ [pop]
   ]                )
 {}               I [pop from empty stack]
]               )

But I wasn't satisfied because it still has two copies of succ. So I changed the "calculate b(n) and apply succ on it" to "apply succ b(n) times to 1", which gives
\n. n (succ succ) 1 succ 1

{}[           n (
  (<><<>()>)    succ [push succ]
  ({})          succ [pop and push succ]
  ]           )
{{}}          I    [1]
{}            succ [pop]
{}            I    [pop from empty stack]

I've just had a glance at the Flurry docs.  I think I'm in love.  Really excited to take this for a drive.

@AdHocGarfHunter I just opened a chat room for Flurry.

Ruby, 29 bytes
f=->a{a<1?2:(b=f[a-1])*~-b+1}

+2 for adding f= to byte count.
-2 from Dingus's suggestion.
Try it online!

Nice, but you need to include f= in the byte count since f is called recursively. You can completely offset the 2 bytes gained from f= by replacing ==0 with <1 and storing the value of f[a-1] (i.e. (b=f[a-1])*~-b).

Vyxal, 7 bytes
-2 bytes thanks to Steffan
2$(:‹*›

Explanation:
2$(:‹*›
2$          Push 2 and swap it with the input
   (:       Loop through input and duplicate value
     ‹*     Decrement the value and multiply
       ›    Increment value

Try it Online!

Global array is almost never a good idea in golfing. -1 byte: 2w$(:Π›J

@Steffan oh wow how didn't I think of that

alternative (completely different) 8-byter with M flag: 2$(…:‹*›

Wait this says to output the nth number, not the first n

so actually, flagless 7: 2$(:‹*›

Julia 1.0, 27 22 bytes
~x=*(1,.~(0:x-1)...)+1

Try it online!
-5 bytes (!!) thanks to MarcMush: Replace prod() with *(); also, pad the argument list with 1 to avoid handling \$a_0\$ as a special case

22 bytes

R,  56 49 bytes
n=scan();x=2;for(i in 1:n){x=c(x,prod(x)+1)};cat(x[n+1])

Ungolfed:
n=scan()            # Take input n
x=2                 # Initialize sequence to 2
for(i in 1:n){
  x=c(x,prod(x)+1)  # Append the product of the previous numbers + 1
}
cat(x[n+1])         # Print the nth + 1 number in seq

Slightly golfed thanks to @Frédéric:
n=scan();x=2;for(i in 1:n)x=c(x,prod(x)+1);x[n+1]

You could golf out some bytes by removing the {...} of the for loop that you don't need here since there's only one instruction in. Moreover, I don't think you absolutely need the cat(...) at the end, even if it looks prettier.

PHP 5.6+ (46 bytes)
function f($n){return--$n?f($n)**2-f($n)+1:2;}

I fail to see the reason of downvote: http://pastebin.com/QxPeUeXB . (Maybe that weird $n; that doesn't seem to do anything?)

I defines $n globaly; Without it, the code doesn't work

Doesn't? :o That I can't explain how I got correct results in my tests. (See the pastebin link in my previous comment. There you can see an interactive session in PHP 5.6.25.)

The downvote was cast by the Community user. It flagged the answer for length and content (only a code snippet, no text description), then marked its flag as helpful when the answer was edited. This triggers the downvote. This is essentially a bug. (CC @manatwork) By the way, the code works just fine for me without the $n;, both locally and on Ideone.

@Dennis, of course it works. In PHP a function can access global variables using the global keyword or the $GLOBALS array.

PowerShell v2+, 56 bytes
param($n)$a=,2;0..$n|%{$a+=($a-join'*')+'+1'|iex};$a[$n]

Iterative version. Takes input, sets the first value in our array $a, loops. Each loop we take all of $a, -join them together with *, tack on a +1, and pipe to Invoke-Expression (similar to eval). That's stored as a new value on the end of $a. Then, we just index into $a for the requested number.
Calculates one index higher than necessary, which shouldn't be a problem. Output is solid until you reach the limits of round-trip precision issues and/or formatting issues where PowerShell converts to scientific notation.
PS C:\Tools\Scripts\golfing> 0..10|%{"$_ -> "+(.\sylvesters-sequence.ps1 $_)}
0 -> 2
1 -> 3
2 -> 7
3 -> 43
4 -> 1807
5 -> 3263443
6 -> 10650056950807
7 -> 1.13423713055422E+26
8 -> 1.28649386832787E+52
9 -> 1.65506647324521E+104
10 -> 2.73924503086033E+208

The recursive version is one byte longer, at 57 bytes, using PowerShell's equivalent of a lambda -- $x={param($n)if(!$n){2}else{(&$x(--$n))*((&$x($n))-1)+1}}. Call it via something like &$x(4)

You could tack on a [bigint] for the iex expression to carry forward the good precision as follows -- param($n)$a=,2;0..$n|%{$a+='[bigint]"'+($a-join'"*"')+'"+"1"'|iex};$a[$n] for 73 bytes (corrected thanks to Brad Gilbert b2gills).
PS C:\Tools\Scripts\golfing> 0..10|%{"$_ -> "+(.\sylvesters-sequence.ps1 $_)}
0 -> 2
1 -> 3
2 -> 7
3 -> 43
4 -> 1807
5 -> 3263443
6 -> 10650056950807
7 -> 113423713055421844361000443
8 -> 12864938683278671740537145998360961546653259485195807
9 -> 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443
10 -> 273924503086030314234102342916746862811943643675809146279473679416086920262269936343321184045824386349295487372839923697584879743063177305807538834294603
44956410077034761330476016739454649828385541500213920807

I'm getting different answers for f(9) and f(10) in the Rakudo implementation of Perl 6 on MoarVM f(9)==165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443 f(10)==27392450308603031423410234291674686281194364367580914627947367941608692026226993634332118404582438634929548737283992369758487974306317730580753883429460344956410077034761330476016739454649828385541500213920807

@BradGilbertb2gills Casting issue. Need to surround the numbers in quotes so the numbers are passed to .TryParse() correctly, otherwise they're on-the-fly converted to [double] and then to [bigint] which loses precision. Thanks for the catch!

MATL, 12 bytes
This can definitely be golfed further
Hiq:"tpQh]0)

This solution uses 1-based indexing.
Try it online!

PARI/GP, 29 25 bytes
a(n)=prod(i=0,n-1,a(i))+1

Thanks to alephalpha for shaving off 4 bytes.

a(n)=prod(i=0,n-1,a(i))+1

@alephalpha Much better! Would you like to give that as an answer, or should I edit it in?

Feel free to edit it in.

Maple 35 bytes
f:=n->`if`(n>0,f(n-1)^2-f(n-1)+1,2)

Usage:
> f:=n->`if`(n>0,f(n-1)^2-f(n-1)+1,2):
> seq(f(i),i=0..4);
  2, 3, 7, 43, 1807

Pip, 11 bytes
Lao*:o+1o+1

The shortest way I've found so far. Uses the formula from Martin's Hexagony answer: define b(0) = 1, b(n) = b(n-1) * (b(n-1) + 1), and then a(n) = b(n) + 1.
La           Loop number of times equal to cmdline input:
  o*:o+1     Multiply o by o+1 in place (o is a variable preinitialized to 1)
        o+1  Output o+1

Try it online!

JavaScript (ES2016), 25 bytes
f=x=>x--?f(x)**2-f(x)+1:2

Uses the zero-indexed sequence.
Here's an example:

f=x=>x--?f(x)**2-f(x)+1:2

const output = document.getElementById('output');

for(let i = 0; i < 10; i++)
  output.textContent += 'f(' + i + ') = ' + f(i) + '\n';
<pre id="output"></pre>

Retina, 43 26 bytes
Input and output are in unary (input in 1's, output in x's.) The result is computed using a(n+1) = a(n) * (a(n) - 1) + 1, iterated n times.
^
xx
{`x(?=.*1)
$`$`
x1
xx

Try it online
Input and output in decimal (53 36 bytes):
.*
$*
^
xx
{`x(?=.*1)
$`$`
}`x1
xx
.

Try it online
Thanks to Martin for golfing 17 bytes

Javascript (ES6), 25 bytes
f=n=>n--?(n=f(n))*--n+1:2

Returns:

the exact result for n=0 to n=6
an approximated value for n=7 to n=10
Infinity for n>10

f=n=>n--?(n=f(n))*--n+1:2

console.log(f(0))
console.log(f(1))
console.log(f(2))
console.log(f(3))
console.log(f(4))
console.log(f(5))
console.log(f(6))
console.log(f(7))

Actually, 14 12 bytes
This used 0-indexing. Golfing suggestions welcome. Try it online!
2#,`;πu@o`nF

Ungolfing:
2#              Start with [2]
  ,`     `n     Take 0-indexed input and run function (input) times
    ;           Duplicate list
     πu         Take product of list and increment
       @o       Swap and append result to the beginning of the list
           F    Return the first item of the resulting list

GolfScript, 12 10 bytes
2 bytes thanks to Dennis.
~2\{.(*)}*

Try it online!
Uses a(n) = a(n-1) * (a(n-1)-1) + 1.

( is short for 1-; ) is short for 1+.

@Dennis Thanks, I must be a special kind of stupid.

Python 3, 71 69 68 63 57 bytes
Python 3, 71 69 68 bytes
l=[2]
for _ in range(int(input())):
    n=1
    for i in l:n*=i
    l+=[n+1]
print(l[-1])

Also 68 bytes:
l=[2]
a=int(input())
while len(l)<a:
    n=1
    for i in l:n*=i
    l+=[n+1]
print(l[-1])

EDIT:
Thanks @WheatWizard for pointing out about using n instead of no, and removing the space between for i in l and n*=i.
Also thanks for pointing out about moving int(input()) into the range function.
EDIT 2:
Thanks @WheatWizard for pointing out the iteration tip, it has allowed me to write these two, shorter, programs:
Python 3, 63 bytes
l=[2]
for _ in"a"*int(input()):
    n=1
    for i in l:n*=i
    l+=[n+1]
print(l[-2])

Python 3, 57 bytes
l=[2]
for _ in"a"*int(input()):
    b=l[-1]
    l+=[(b-1)*b+1]
print(b)

The second code (57 bytes) does not follow the instructions for making the sequence (i.e: product of the sequence+1) instead it works on the fact that the last number will always be the product of the rest+1 meaning that instead of iterating through the sequence, I can multiply the last number by itself-1 and then add 1 back on.

You can lose the space between the : and the no*=i.

plus no can be renamed to n

You could also move the int(input()) into the range() and print l[-1] instead of l[a]

You seem to have forgotten to make changes on line 5.

The space is still there...

You can change range(int(input())) to [l]*int(input) and drop the space after in.

@WheatWizard I don't think that would work, because python needs the range function too iterate through an integer

Since you iterate using _ it doesn't matter what is in the array only the length.  You should try my suggestion. It seems to work on my end.

It might make more intuitive sense as "a"*int(input()) which works equally well.

@WheatWizard, sorry, I had misunderstood what you meant the first time as I had forgotten that you could multiply strings and lists by integers.

Let us continue this discussion in chat.

Perl, 28 26 23 22 bytes
Includes +1 for -p
Run with the input (with 1-based indexing) on STDIN:
sylvester.pl <<< 5

sylvester.pl:
#!/usr/bin/perl -p
$.*=$_=$.+1for($_)x$_

Dyalog APL, 15 bytes
{×⍵:1+×/∇¨⍳⍵⋄2}

×⍵: if the argument is grater than zero:
  1+ one plus
  ×/ the product of
  ∇¨ this function applied to each of
  ⍳⍵ first n integers (beginning with zero)
⋄ else:
  2 return two
0-based indexing – needs ⎕IO←0.
TryAPL online!

I had tried {1+×/∇¨⍳⍵} before, but that resulted in a WS FULL message. Why does iterating over an empty list cause infinite recursion though? It works as (I) expected with ngn-apl.

@Dennis It is because empty lists are not really that empty: They carry information about their prototype element, obtainable with ⊃EmptyList. Thus, for user-defined functions, the function is called once on empty lists, to determine the prototype. Interestingly, this leads to the possibility of storing any amount of arbitrary information in an "empty" variable.

@Dennis Set Encode←{0⍴⊂0' '[2⊥⍣¯1⎕UCS ⍵]} ⋄ Decode←{⎕UCS 2⊥0' '∘⍳¨⊃⍵}. Then try ⍴crypt←Encode '{×⍵:1+×/∇¨⍳⍵⋄2}' with Decode crypt and ⍴crypt←Encode 8 5⍴'  |   /_\  |A|  |P|  |L|  |_| /___\ VvV' with Decode crypt.

dc, 34 bytes
0sg[[d1-*1+Lgx]Sg1-d0<f]dsfx2Lgx++

This pops the argument from top of stack, and pushes the result to stack, as normal for dc.
Annotated full program
#!/usr/bin/dc

# accept input
?

# initialise the bottom of the g-stack
0sg
# Add n iterations of recurrence formula
[[d1-*1+Lgx]Sg1-d0<f]dsfx
# Prime the 0th value
2
# Execute all of the g-stack
Lgx
# Last instruction left a zero on the stack
+
# Special case: if input is 0, f left a -1 behind.  This is a correction
# for wrongly doing 2->3 in that case
+

# print output
p

It works by using the recurrence relation described in OEIS: a[n+1] = a[n]² - a[n] + 1, starting with a[0]==2.  Equivalently, a[n+1] = a[n](a[n]-1) + 1, written in dc as d1-*1+.
We push n copies of the program d1-*1+ to the stack g, prime the main stack with the initial value 2, and set off.  There's a correction for n=0, because we always push at least one instance of the recurrence.  Handily, we can fix that, because function f leaves -1 on the stack in that case, and 0 otherwise.
Test output:
0: 2
1: 3
2: 7
3: 43
4: 1807
5: 3263443
6: 10650056950807
7: 113423713055421844361000443
8: 12864938683278671740537145998360961546653259485195807
9: 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443
10: 27392450308603031423410234291674686281194364367580914627947367941608692026226993634332118404582438634929548737283992369758487974306317730580753883429460344956410077034761330476016739454649828385541500213920807
11: 750346333909286311464218348364293017384724140073732363176684391768374238237200233203724274839819736227493060107386942069521875902258281351952761393460726027774387698896086030486687796275661950199835484418384103096899499524666007073298797852932127876923983340497448231960048833094195425231846478785035602339261149953564729371337917773386670133413581537490788020231265093210310224397095644371148893261284201611453610443
12: 563019620811106188735345793029131127645126456201508328395934709948713369875017428398616526515350801978901280848429236023780360625686785326318172135941491985234945009397938528773976977887356630327917721419666751591559883455828027643329740930320548089836575156581070880066847294722353255119648341271402723167206816552066010592134725124376810874159292118224274440907862996344067325025151751506647339684959479438354192989470470488621172745980086435801519575581664038703641801974453354864238123148678312993828328158261237284571445163949954735321181426755485563860804935755099928085508785637606452207007984638610604113718738727804169240213041488645142155664706600019329809186121988322464207409749450811638629159492106903853533242008723387118397794980575878357156285111258733862431522178328441469980110808406224908967784943255608168545045807
13: 316991093418281796980738587324498503465985663563441351614965595710659626509023026378810664917769979749230375616949095839488230630774365784766585678394020150307543448990686716629735821013846949520218610883960194258122308878890968113466913053158083723070515602776324450012006168592325685889943262781933132780014500164781142497008320197365141855119010118077705678576368755229432787283587491897170937657553086679827144799087397199129432233281774986701578182361474362882421927116451702868297347253630717771757957438615228337552613006602138504913204731416596016919892552584014059657038635241014722034375088903021315484876024289828564177721518967548558336213757430766087730295001595138792039193609746512786881659903942227205537012891959828532940594409566163694454653037016800027294499421291400492041597627904670868358757293568071192353450861046220903121264904877170553117406388566305811088048722332066039563082830094354238880920553702156022717609505663704069061610519598560624334935881397512984533454362321248854729174814176943381209734396537109715522733592519084452225492188715705481658124794599731527140827530319488791822858978924780015280035310521766457660381662363459675166288099343838361130665940967928850877954452552005403436587169730515877297387774041696625714088910160966686976352250237188765370786055553236020704945964404004577531357576565107610684603955726197582253686411381871520005412537060114403951740688011605681233186481569161991920354077827812176666950510226500521720520469387009627382085749910481677989034236154462513159644551504513525508614268492165297534777956118363272320828495465015734808069866823697938666550506233479919235237378935603448169915183235443
14: 100483353306517857188816511171973264968130481955993490961776578914384855009465596512878627978186320098524674810822809215084298821790532480217571435837318997038501027166944291436298311859998927368878478765662052261013905379683606908563327049366289350227874801320137528476359434996625155321924896471487253609774383161294073700386567438895729619959183688827019175395384990049660760826706275656247200320644562229907983316938796200727194177710641698165578469600709422183645673081099011178658794923207340118316226811044120124994280172667435132674250477913878334229469634774955766654959747171269329356217729819952093850230832136940392143299736102334976183356619572749168857678782222255344301700168226608019630704240193738779198063738629831841413772846575231497629810592678428725195220732911880790353530776313807267315574488856933933931968726196972550157616749777588888821303729634383570842953721086839502335017753789603211887639264756326943906234925564059713122739441052488376985825209930025027331642643833862623818612641648534007690784009230583997364206027891426162271405399576520661523570494921380174573570295575834537952976231451138917903119690734728050868143651943079046629073247009723903287946523072583428647088990713577505274669321894108556505593299658881909461644436220683735665670039545950199079805499092674406353548516096407916275052371510047476698658893306349068133879014809524920709542592832744670134019181012820484031829100985336532444887396195766078330294774788615792775829183741076029977456631131003360810557200089618493958319779112283680033864350359591347851857639767660909655544622503481811302270128415655545885368248621757558781407774929247336942808205264958129961178967782261436710020914320953492879039247990865098954170193648898076402861312803632817456574773061811978648089614340109760702469211985641224691799075765885167117855362986656144090527289697873066081524676142089795828969028242126025160985084779781007974719610529121366009147473928798323429514961662955075830495059188425232901129844306717176754536658533793214326255403412914373598713551532524170357661947859352181097102731800860434424406585016086605044703266455861041380556886689319004123095655013285849524741495205262970148746426581276319938997140587845485798731493239638046736464142096404810367841352036464369335995230683471276720095626585363049720580305501778636182605592068492151793190258602236893550140479021220581841241476297575889705144565984983772835663470728331437295945770147420128139970898197153180098987682528952187399111614545313650329728193759220800741639763444502297436225484681500013482802572032911312979385547883726365017125898034265710900263014307543995711388447583272341504352098242603013317289071851486202200363353430637400418445403028209289752937101610106546407815385279051077386957963745649023423516876644029840971378691516442745761797057396994687382618710236478541855961623090443801434726418529440871490091117324165342131670988126442133481305788646667033011070351616554711007362680081909808994105138595194669575127185645557552945017168697977343707144183186705714691228418618276386168995938283316172058534438295911377445943568762495111242585896098376432273844229629284777619272064792008892485171141118486114024760197688360378085790695965894817048250719620713759873671293320363983916413298621510321025850259140267373664767105414000002388170807
15: [encoded data, 6671 characters]
16: (13341 digits)
17: (26681 digits)
18: (53361 digits)
19: (106721 digits)
20: (213441 digits)
21: (426881 digits)
22: (853761 digits)
23: (1707522 digits)
24: (3415043 digits)
25: (6830085 digits)
26: (13660169 digits)
27: (27320338 digits)
28: (54640675 digits)
29: (109281349 digits)

As you can see, these numbers grow quite rapidly; the computation time also increases in the same proportion as the result length. It took me half a minute to compute a(23), and several hours for a(29).

Groovy, 26 bytes
This answer was basically stolen from @Geobits.
a={n->n--?a(n)*~-a(n)+1:2}

Took that answer and, using groovy shortcuts, optimized it further.

Common Lisp, 53 bytes
(defun f(n)(do((x 2(1+(* x(1- x)))))((<(decf n)0)x)))

The result is computed through the formula a(n+1) = a(n) * (a(n) - 1) + 1, starting from 2 and iterated n times.

Japt -g, 6 bytes
Takes input as a singleton integer array, 1-indexed.
ÇÆiU×Ä

Try it
Japt -h, 6 bytes
Takes input as an integer, 1-indexed.
ÆßX ×Ä

Try it
Original w/o flag, 9 8 bytes
Takes input as an integer, 0-indexed.
@ÒZ×}gNÅ

Try it

Husk, 11 7 bytes
!¡o→Π;2

Try it online!
1-indexed.
-4 bytes from Leo.

!S:¹ are redundant ;) https://tio.run/##yygtzv7/X/HQwvxHbZPOLbA2@v//vykA

@Leo This was one of my first ones, so it's badly golfed :P

I suspected that, but I was about to post a solution when I found yours that contained mine :D

AWK, 32 bytes
{for(n=2;$0>i++;n=n*n-n+1);}$1=n

Try it online!

Vyxal m, 5 bytes
λvxΠ›

Try it Online!
Jelly port.

Thunno 2, 7 bytes
2${D⁻×⁺

Attempt This Online!
Port of Emigna's 05AB1E answer.
Explanation
2${D⁻×⁺  # Implicit input
2        # Start with 2
 ${      # Input number of times:
   D⁻×   #  Multiply by x-1
      ⁺  #  And increment
         # Implicit output

Scala, 85 bytes (51?)
val s:Stream[BigInt]=2#::3#::s.tail.map{c=>c*c-c+1}
print(s.take(args(0).toInt).last)

3 less if I stick with an Int. The stream bit which actually does all the work is 51 bytes. The rest is just printing
Usage:
$ scala sylvester.scala 20

Batch, 70 bytes
@set/ap=r=2
@for /l %%i in (1,1,%1)do @set/at=p,p*=r,r=t+1
@echo %r%

Zero indexed, uses @LeakyNun's recurrence relation. Conveniently set/a works inside a for loop, because I'm not using % substitution.

Javascript (Using external library - Enumerable) (52 bytes)
n=>_.Sequence(n,(i,a)=>_.From(a).Product()+1).Last()

Link to lib: https://github.com/mvegh1/Enumerable
Code explanation: Static method on library "Sequence" will generate a sequence of elements for a count of 'n', according to the predicate accepting params "i"teration, "a"ccumulated-array. The predicate states to cast the array to the library's Enumerable data-type, use the built in Product method on it, then add 1 to that value. After the sequence is generated, take the last value because the problem states to just find the 'N'th element of the sequence

Sesos, 17 bytes
Hexdump:
0000000: ae2cf0 20f8be b273d0 7d9cde a0dd3b 7e3e           .,. ...s.}....;~>

Try it online!

UGL, 15 bytes
cuuild@$d*u@:_o

Try it online!

Pyke, 9 bytes
[SOm[BhRK

Try it here!

Perl, 35 bytes
$a=2;$a=$a**2-$a+1 for 1..<>;say $a

Might be shorter with a recursive function but I couldn't get that to work in my few attempts

Perl6, 49 bytes
my &f={my @c=2;@c.push: 1+[*] @c for ^$_;@c[*-1]}

Ungolfed:
sub f($n) {
  my @sylvester = 2; # declare an array to store the previous
                     # values of the sequence
  # insert S(1) ... S(n) (n iterations)
  @sylvester.push(1 + [*] @sylvester) for 0..^$n;
  return @sylvester[* - 1]; # return last element
}

You don't need to include my&f= in these competitions, an anonymous code object is fine.

C, 44 bytes
g(i,j){return i<2?2:(j=g(i-1,0),j*(j-1)+1);}

ForceLang, 193 bytes
Noncompeting, as for some reason I forgot to give the language's lists a len method when I first implemented them.
def s set
def l a.len()
s g goto
s n io.readnum()
s n n+1
s a []
s b 1
label 1
s n n+-1
s a[l] b+1
if n=0
g 3
s b 1
s i 0
label 2
s b b.mult a[i]
s i i+1
if i=l
g 1
g 2
label 3
io.write a[l+-1]

Racket 74 bytes
(define(f n(l'(2)))(if(< n 2)(reverse l)(f(- n 1)(cons(+(apply * l)1)l))))

Detailed version:
(define (f n (l '(2)))
  (if (< n 2)
      (reverse l)
      (f (- n 1) (cons (+ 1 (apply * l)) l))))

Testing:
(f 7)

Output:
'(2 3 7 43 1807 3263443 10650056950807)

C#, 144 Bytes
I used one indexing:
Golfed:
int s(int n){var a=new int[n];int b=1;for(int i=0;i<a.Length;i++){a[i]=b;b=1;a.ToList().GetRange(0,i).ForEach(o=>b*=o);a[i]=b+1;}return a[n-1];}

Ungolfed:
class SylvestersSequence
{
public int s(int n)
{
  var a = new int[n];

  int b = 1;

  for (int i = 0; i < a.Length; i++)
  {
    a[i] = b;

    b = 1;

    a.ToList().GetRange(0, i).ForEach(o => b *= o);

    a[i] = b + 1;
  }

  return a[n - 1];
}
}

Tests:
1 : 2
2 : 3
3 : 7
4 : 43
5 : 1807
6 : 3263443

(Things start to go a bit weird after this...)

Forth (gforth), 35 bytes
Answer uses 0-indexing

: f 2 swap 0 ?do dup 1- * 1+ loop ;

Try it online!
Explanation

place 2 on stack
loop from 0 to n-1

multiply top of stack by itself minus 1
add 1

Code Explanation
: f             \ Start a new word definition
  2 swap        \ place 2 on the top of the stack
  0 ?do         \ loop from 0 to n-1 (skip loop if n=0)
    dup 1-      \ duplicate top of stack and subtract 1
    *           \ multiply top two stack values
    1+          \ add 1 to result
  loop          \ end loop
;               \ end word definition

05AB1E, 8 bytes
2λλP>}sè

Not shorter than the existing 05AB1E (legacy) answer by @Emigna, but I wanted to try out the new recursive function in the 05AB1E Elixir-rewrite.
Try it online or verify all test cases.
Explanation:
2λ   }      # Define a recursive sequence function starting at a(0) = 2
  λ         #  Generates a recursive infinite sequence-list [a(0), a(1), a(2), ...]
   P>       #  where each a(n) takes the product + 1 of all previous results
            #   i.e. [2,3,7,43,1807,3263443,10650056950807,...]
      s     # Swap so the input is at the top of the stack
       è    # Get the 0-indexed value of the infinite recursive sequence-list
            #  i.e. 4 and [2,3,7,43,1807,3263443,10650056950807,...] → 1807

C++, 43 bytes
[&](int n){return n?f(n-1)*(f(n-1)-1)+1:2;}

Try it Online!

42 bytes

cQuents, 9 bytes
=2:ZZ-Z+1

1-indexed.
Try it online!
Explanation
=2          first term is 2
  :         given input n, output nth term
            each term equals
   ZZ-Z+1   previous * previous - previous + 1

Zsh, 35 bytes
for ((A=2;n++<$1;A=A*~-A+1)):
<<<$A

Try it online!

JavaScript, 28 bytes
A function. Expect a number as input.
f=n=>n?f(n-1)*(f(n-1)-1)+1:2
Using the formula a[n] = a[n-1] * ( a[n-1] - 1 ) + 1.
Explanation. The ungolfed and commented version:
var f = (n) => {                 // Define a function
  n ?                            // If n is not zero...
                                 // (non-negative numbers and TRUE booleans are
                                 // equivalent in JavaScript)
    f(n-1) * (f(n-1) - 1) + 1    // Then use the recurrence formula.
    :                            // Else, if n is zero...
    2                            // Return 2 to end recurrence.
}

In case you didn't know, you can use Try It Online to generate formatted answers (click link icon at the top).

@Dingus Unfortunately I'm in a region which can't access TIO. Definitely I know that website :D

MMIX, 24 bytes (6 instrs)
Works mod \$2^{64}\$. One-based indexing.
(jxd)
00000000: e3ff0001 2301ff01 1affff01 27000001  ẉ”¡¢#¢”¢ȷ””¢'¡¡¢
00000010: 5b00fffd f8020000                    [¡”’ẏ£¡¡

Disassembly:
sylv    SET  $255,1         // b(1)=1
0H      ADDU $1,$255,$1     // loop: a(n) = b(n) + 1
        MULU $255,$255,$1   // b(n+1) = a(n) * b(n)
        SUBU $0,$0,1
        PBNZ $0,0B          // if(--i) goto loop
        POP  2,0            // return a

Fig, \$5\log_{256}(96)\approx\$ 4.116 bytes
}rMXr

Try it online!
Port of Jelly. Link contains extra code to run all test cases.
}rMXr
    r # Range [0, n)
  MX  # Map by this function
 r    # Product
}     # Increment

Go, 59 bytes, int only
func f(n int)int{if n<1{return 2}
k:=f(n-1)
return k*k-k+1}

Attempt This Online!
Go, 126 bytes, arbitrarily large outputs
import."math/big"
func f(n int)*Int{i,l:=NewInt,new(Int)
if n<1{return i(2)}
k:=f(n-1)
return l.Add(l.Sub(l.Mul(k,k),k),i(1))}

Attempt This Online!

Nekomata, 7 bytes
2ᶦ{:←*→

Attempt This Online!
Takes no input, and outputs all terms of the Sylvester's sequence.
2ᶦ{:←*→
2           Start with 2
 ᶦ{         Infinite loop:
   :            Duplicate
    ←           Decrement
     *          Multiply
      →         Increment

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/